2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 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
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 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
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 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
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 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
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 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
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 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
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 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
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 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
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 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
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 125: return ((char *) HT_00125
); break;
5695 case 130: return ((char *) HT_00130
); break;
5696 case 131: return ((char *) HT_00131
); break;
5697 case 132: return ((char *) HT_00132
); break;
5698 case 133: return ((char *) HT_00133
); break;
5699 case 140: return ((char *) HT_00140
); break;
5700 case 141: return ((char *) HT_00141
); break;
5701 case 150: return ((char *) HT_00150
); break;
5702 case 160: return ((char *) HT_00160
); break;
5703 case 190: return ((char *) HT_00190
); break;
5704 case 200: return ((char *) HT_00200
); break;
5705 case 300: return ((char *) HT_00300
); break;
5706 case 400: return ((char *) HT_00400
); break;
5707 case 500: return ((char *) HT_00500
); break;
5708 case 501: return ((char *) HT_00501
); break;
5709 case 900: return ((char *) HT_00900
); break;
5710 case 910: return ((char *) HT_00910
); break;
5711 case 1000: return ((char *) HT_01000
); break;
5712 case 1100: return ((char *) HT_01100
); break;
5713 case 1400: return ((char *) HT_01400
); break;
5714 case 1410: return ((char *) HT_01410
); break;
5715 case 1420: return ((char *) HT_01420
); break;
5716 case 1421: return ((char *) HT_01421
); break;
5717 case 1430: return ((char *) HT_01430
); break;
5718 case 1440: return ((char *) HT_01440
); break;
5719 case 1441: return ((char *) HT_01441
); break;
5720 case 1450: return ((char *) HT_01450
); break;
5721 case 1460: return ((char *) HT_01460
); break;
5722 case 1500: return ((char *) HT_01500
); break;
5723 case 1600: return ((char *) HT_01600
); break;
5724 case 1700: return ((char *) HT_01700
); break;
5725 case 1710: return ((char *) HT_01710
); break;
5726 case 1711: return ((char *) HT_01711
); break;
5727 case 1720: return ((char *) HT_01720
); break;
5728 case 1722: return ((char *) HT_01722
); break;
5729 case 1730: return ((char *) HT_01730
); break;
5730 case 1731: return ((char *) HT_01731
); break;
5731 case 1740: return ((char *) HT_01740
); break;
5732 case 1750: return ((char *) HT_01750
); break;
5733 case 1760: return ((char *) HT_01760
); break;
5734 case 1800: return ((char *) HT_01800
); break;
5735 case 2100: return ((char *) HT_02100
); break;
5736 case 2400: return ((char *) HT_02400
); break;
5737 case 2410: return ((char *) HT_02410
); break;
5738 case 2500: return ((char *) HT_02500
); break;
5739 case 2600: return ((char *) HT_02600
); break;
5740 case 2611: return ((char *) HT_02611
); break;
5741 case 2612: return ((char *) HT_02612
); break;
5742 case 2711: return ((char *) HT_02711
); break;
5743 case 2811: return ((char *) HT_02811
); break;
5744 case 3000: return ((char *) HT_03000
); break;
5745 case 3100: return ((char *) HT_03100
); break;
5746 case 3200: return ((char *) HT_03200
); break;
5747 case 3710: return ((char *) HT_03710
); break;
5748 case 3711: return ((char *) HT_03711
); break;
5749 case 3800: return ((char *) HT_03800
); break;
5750 case 4300: return ((char *) HT_04300
); break;
5751 case 4400: return ((char *) HT_04400
); break;
5752 case 4500: return ((char *) HT_04500
); break;
5753 case 4700: return ((char *) HT_04700
); break;
5754 case 4800: return ((char *) HT_04800
); break;
5755 case 4900: return ((char *) HT_04900
); break;
5756 case 5000: return ((char *) HT_05000
); break;
5757 case 5100: return ((char *) HT_05100
); break;
5758 case 5200: return ((char *) HT_05200
); break;
5759 case 5300: return ((char *) HT_05300
); break;
5760 case 5400: return ((char *) HT_05400
); break;
5761 case 5500: return ((char *) HT_05500
); break;
5762 case 5600: return ((char *) HT_05600
); break;
5763 case 5700: return ((char *) HT_05700
); break;
5764 case 5800: return ((char *) HT_05800
); break;
5765 case 6000: return ((char *) HT_06000
); break;
5766 case 6100: return ((char *) HT_06100
); break;
5767 case 6211: return ((char *) HT_06211
); break;
5768 case 6212: return ((char *) HT_06212
); break;
5769 case 6213: return ((char *) HT_06213
); break;
5770 case 6221: return ((char *) HT_06221
); break;
5771 case 6222: return ((char *) HT_06222
); break;
5772 case 6223: return ((char *) HT_06223
); break;
5773 case 6231: return ((char *) HT_06231
); break;
5774 case 6232: return ((char *) HT_06232
); break;
5775 case 6233: return ((char *) HT_06233
); break;
5776 case 6241: return ((char *) HT_06241
); break;
5777 case 6242: return ((char *) HT_06242
); break;
5778 case 6243: return ((char *) HT_06243
); break;
5779 case 6300: return ((char *) HT_06300
); break;
5780 case 6400: return ((char *) HT_06400
); break;
5781 case 6500: return ((char *) HT_06500
); break;
5782 case 6600: return ((char *) HT_06600
); break;
5783 case 6700: return ((char *) HT_06700
); break;
5784 case 6800: return ((char *) HT_06800
); break;
5785 case 6900: return ((char *) HT_06900
); break;
5786 case 7100: return ((char *) HT_07100
); break;
5787 case 7200: return ((char *) HT_07200
); break;
5788 case 7300: return ((char *) HT_07300
); break;
5789 case 7400: return ((char *) HT_07400
); break;
5790 case 7500: return ((char *) HT_07500
); break;
5791 case 7600: return ((char *) HT_07600
); break;
5792 case 7700: return ((char *) HT_07700
); break;
5793 case 7800: return ((char *) HT_07800
); break;
5794 case 7900: return ((char *) HT_07900
); break;
5795 case 8000: return ((char *) HT_08000
); break;
5796 case 8100: return ((char *) HT_08100
); break;
5797 case 8200: return ((char *) HT_08200
); break;
5798 case 8300: return ((char *) HT_08300
); break;
5799 case 8400: return ((char *) HT_08400
); break;
5800 case 8500: return ((char *) HT_08500
); break;
5801 case 8600: return ((char *) HT_08600
); break;
5802 case 8700: return ((char *) HT_08700
); break;
5803 case 8800: return ((char *) HT_08800
); break;
5804 case 8900: return ((char *) HT_08900
); break;
5805 case 9000: return ((char *) HT_09000
); break;
5806 case 9100: return ((char *) HT_09100
); break;
5807 case 9200: return ((char *) HT_09200
); break;
5808 case 9300: return ((char *) HT_09300
); break;
5809 case 9400: return ((char *) HT_09400
); break;
5810 case 9500: return ((char *) HT_09500
); break;
5811 case 9600: return ((char *) HT_09600
); break;
5812 case 9700: return ((char *) HT_09700
); break;
5813 case 9710: return ((char *) HT_09710
); break;
5814 case 9720: return ((char *) HT_09720
); break;
5815 case 9800: return ((char *) HT_09800
); break;
5816 case 9810: return ((char *) HT_09810
); break;
5817 case 9820: return ((char *) HT_09820
); break;
5818 case 9900: return ((char *) HT_09900
); break;
5819 case 10000: return ((char *) HT_10000
); break;
5820 case 10100: return ((char *) HT_10100
); break;
5821 case 10200: return ((char *) HT_10200
); break;
5822 case 10300: return ((char *) HT_10300
); break;
5823 case 10400: return ((char *) HT_10400
); break;
5824 case 10410: return ((char *) HT_10410
); break;
5825 case 10420: return ((char *) HT_10420
); break;
5826 case 10500: return ((char *) HT_10500
); break;
5827 case 10600: return ((char *) HT_10600
); break;
5828 case 10700: return ((char *) HT_10700
); break;
5829 case 10800: return ((char *) HT_10800
); break;
5830 case 10900: return ((char *) HT_10900
); break;
5831 case 11000: return ((char *) HT_11000
); break;
5832 case 11100: return ((char *) HT_11100
); break;
5833 case 11200: return ((char *) HT_11200
); break;
5834 case 11300: return ((char *) HT_11300
); break;
5835 case 11400: return ((char *) HT_11400
); break;
5836 case 11500: return ((char *) HT_11500
); break;
5837 case 11600: return ((char *) HT_11600
); break;
5838 case 11700: return ((char *) HT_11700
); break;
5839 case 11800: return ((char *) HT_11800
); break;
5840 case 11900: return ((char *) HT_11900
); break;
5841 case 12000: return ((char *) HT_12000
); break;
5842 case 12100: return ((char *) HT_12100
); break;
5843 case 12200: return ((char *) HT_12200
); break;
5844 case 12300: return ((char *) HT_12300
); break;
5845 case 12400: return ((char *) HT_12400
); break;
5846 case 12500: return ((char *) HT_12500
); break;
5847 case 12600: return ((char *) HT_12600
); break;
5848 case 12700: return ((char *) HT_12700
); break;
5849 case 12800: return ((char *) HT_12800
); break;
5850 case 12900: return ((char *) HT_12900
); break;
5851 case 13000: return ((char *) HT_13000
); break;
5852 case 13100: return ((char *) HT_13100
); break;
5853 case 13200: return ((char *) HT_13200
); break;
5854 case 13300: return ((char *) HT_13300
); break;
5855 case 13400: return ((char *) HT_13400
); break;
5856 case 13500: return ((char *) HT_13500
); break;
5859 return ((char *) "Unknown");
5862 char *strstatus (const uint devices_status
)
5864 switch (devices_status
)
5866 case STATUS_INIT
: return ((char *) ST_0000
); break;
5867 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5868 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5869 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5870 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5871 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5872 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5873 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5874 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5875 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5876 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5879 return ((char *) "Unknown");
5882 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5884 uint hash_type
= data
.hash_type
;
5885 uint hash_mode
= data
.hash_mode
;
5886 uint salt_type
= data
.salt_type
;
5887 uint opts_type
= data
.opts_type
;
5888 uint opti_type
= data
.opti_type
;
5889 uint dgst_size
= data
.dgst_size
;
5891 char *hashfile
= data
.hashfile
;
5895 uint digest_buf
[64] = { 0 };
5897 u64
*digest_buf64
= (u64
*) digest_buf
;
5899 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5901 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5903 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5909 case HASH_TYPE_DESCRYPT
:
5910 FP (digest_buf
[1], digest_buf
[0], tt
);
5913 case HASH_TYPE_DESRACF
:
5914 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5915 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5917 FP (digest_buf
[1], digest_buf
[0], tt
);
5921 FP (digest_buf
[1], digest_buf
[0], tt
);
5924 case HASH_TYPE_NETNTLM
:
5925 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5926 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5927 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5928 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5930 FP (digest_buf
[1], digest_buf
[0], tt
);
5931 FP (digest_buf
[3], digest_buf
[2], tt
);
5934 case HASH_TYPE_BSDICRYPT
:
5935 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5936 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5938 FP (digest_buf
[1], digest_buf
[0], tt
);
5943 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5948 digest_buf
[0] += MD4M_A
;
5949 digest_buf
[1] += MD4M_B
;
5950 digest_buf
[2] += MD4M_C
;
5951 digest_buf
[3] += MD4M_D
;
5955 digest_buf
[0] += MD5M_A
;
5956 digest_buf
[1] += MD5M_B
;
5957 digest_buf
[2] += MD5M_C
;
5958 digest_buf
[3] += MD5M_D
;
5961 case HASH_TYPE_SHA1
:
5962 digest_buf
[0] += SHA1M_A
;
5963 digest_buf
[1] += SHA1M_B
;
5964 digest_buf
[2] += SHA1M_C
;
5965 digest_buf
[3] += SHA1M_D
;
5966 digest_buf
[4] += SHA1M_E
;
5969 case HASH_TYPE_SHA256
:
5970 digest_buf
[0] += SHA256M_A
;
5971 digest_buf
[1] += SHA256M_B
;
5972 digest_buf
[2] += SHA256M_C
;
5973 digest_buf
[3] += SHA256M_D
;
5974 digest_buf
[4] += SHA256M_E
;
5975 digest_buf
[5] += SHA256M_F
;
5976 digest_buf
[6] += SHA256M_G
;
5977 digest_buf
[7] += SHA256M_H
;
5980 case HASH_TYPE_SHA384
:
5981 digest_buf64
[0] += SHA384M_A
;
5982 digest_buf64
[1] += SHA384M_B
;
5983 digest_buf64
[2] += SHA384M_C
;
5984 digest_buf64
[3] += SHA384M_D
;
5985 digest_buf64
[4] += SHA384M_E
;
5986 digest_buf64
[5] += SHA384M_F
;
5987 digest_buf64
[6] += 0;
5988 digest_buf64
[7] += 0;
5991 case HASH_TYPE_SHA512
:
5992 digest_buf64
[0] += SHA512M_A
;
5993 digest_buf64
[1] += SHA512M_B
;
5994 digest_buf64
[2] += SHA512M_C
;
5995 digest_buf64
[3] += SHA512M_D
;
5996 digest_buf64
[4] += SHA512M_E
;
5997 digest_buf64
[5] += SHA512M_F
;
5998 digest_buf64
[6] += SHA512M_G
;
5999 digest_buf64
[7] += SHA512M_H
;
6004 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6006 if (dgst_size
== DGST_SIZE_4_2
)
6008 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6010 else if (dgst_size
== DGST_SIZE_4_4
)
6012 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6014 else if (dgst_size
== DGST_SIZE_4_5
)
6016 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6018 else if (dgst_size
== DGST_SIZE_4_6
)
6020 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6022 else if (dgst_size
== DGST_SIZE_4_8
)
6024 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6026 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6028 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6030 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6032 else if (hash_type
== HASH_TYPE_SHA384
)
6034 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6036 else if (hash_type
== HASH_TYPE_SHA512
)
6038 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6040 else if (hash_type
== HASH_TYPE_GOST
)
6042 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6045 else if (dgst_size
== DGST_SIZE_4_64
)
6047 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6049 else if (dgst_size
== DGST_SIZE_8_25
)
6051 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6055 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6056 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6057 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6063 memset (&salt
, 0, sizeof (salt_t
));
6065 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6067 char *ptr
= (char *) salt
.salt_buf
;
6069 uint len
= salt
.salt_len
;
6071 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6077 case HASH_TYPE_NETNTLM
:
6079 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6080 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6082 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6088 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6090 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6098 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6100 uint max
= salt
.salt_len
/ 4;
6104 for (uint i
= 0; i
< max
; i
++)
6106 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6110 if (opts_type
& OPTS_TYPE_ST_HEX
)
6112 char tmp
[64] = { 0 };
6114 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6116 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6121 memcpy (ptr
, tmp
, len
);
6124 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6126 memset (ptr
+ len
, 0, memset_size
);
6128 salt
.salt_len
= len
;
6132 // some modes require special encoding
6135 uint out_buf_plain
[256] = { 0 };
6136 uint out_buf_salt
[256] = { 0 };
6138 char tmp_buf
[1024] = { 0 };
6140 char *ptr_plain
= (char *) out_buf_plain
;
6141 char *ptr_salt
= (char *) out_buf_salt
;
6143 if (hash_mode
== 22)
6145 char username
[30] = { 0 };
6147 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6149 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6151 u16
*ptr
= (u16
*) digest_buf
;
6153 tmp_buf
[ 0] = sig
[0];
6154 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6155 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6156 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6157 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6158 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6159 tmp_buf
[ 6] = sig
[1];
6160 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6161 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6162 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6163 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6164 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6165 tmp_buf
[12] = sig
[2];
6166 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6167 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6168 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6169 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6170 tmp_buf
[17] = sig
[3];
6171 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6172 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6173 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6174 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6175 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6176 tmp_buf
[23] = sig
[4];
6177 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6178 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6179 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6180 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6181 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6182 tmp_buf
[29] = sig
[5];
6184 snprintf (out_buf
, len
-1, "%s:%s",
6188 else if (hash_mode
== 23)
6190 // do not show the skyper part in output
6192 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6194 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6196 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6203 else if (hash_mode
== 101)
6205 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6211 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6213 memcpy (tmp_buf
, digest_buf
, 20);
6215 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6217 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6219 else if (hash_mode
== 111)
6221 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6223 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6224 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6225 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6226 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6227 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6229 memcpy (tmp_buf
, digest_buf
, 20);
6230 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6232 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6234 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6236 else if ((hash_mode
== 122) || (hash_mode
== 125))
6238 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6239 (char *) salt
.salt_buf
,
6246 else if (hash_mode
== 124)
6248 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6249 (char *) salt
.salt_buf
,
6256 else if (hash_mode
== 131)
6258 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6259 (char *) salt
.salt_buf
,
6267 else if (hash_mode
== 132)
6269 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6270 (char *) salt
.salt_buf
,
6277 else if (hash_mode
== 133)
6279 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6281 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6282 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6283 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6284 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6285 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6287 memcpy (tmp_buf
, digest_buf
, 20);
6289 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6291 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6293 else if (hash_mode
== 141)
6295 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6297 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6299 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6301 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6303 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6304 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6305 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6306 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6307 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6309 memcpy (tmp_buf
, digest_buf
, 20);
6311 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6315 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6317 else if (hash_mode
== 400)
6319 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6321 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6322 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6323 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6324 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6326 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6328 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6330 else if (hash_mode
== 500)
6332 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6334 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6335 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6336 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6337 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6339 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6341 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6343 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6347 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6350 else if (hash_mode
== 501)
6352 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6354 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6355 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6357 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6359 else if (hash_mode
== 1421)
6361 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6363 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6379 else if (hash_mode
== 1441)
6381 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6383 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6385 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6387 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6389 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6390 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6391 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6392 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6393 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6394 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6395 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6396 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6398 memcpy (tmp_buf
, digest_buf
, 32);
6400 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6404 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6406 else if (hash_mode
== 1500)
6408 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6409 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6410 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6411 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6412 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6414 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6416 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6418 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6419 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6421 memcpy (tmp_buf
, digest_buf
, 8);
6423 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6425 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6429 else if (hash_mode
== 1600)
6431 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6433 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6434 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6435 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6436 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6438 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6440 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6442 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6446 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6449 else if (hash_mode
== 1711)
6451 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6453 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6454 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6455 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6456 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6457 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6458 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6459 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6460 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6462 memcpy (tmp_buf
, digest_buf
, 64);
6463 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6465 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6467 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6469 else if (hash_mode
== 1722)
6471 uint
*ptr
= digest_buf
;
6473 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6474 (unsigned char *) salt
.salt_buf
,
6484 else if (hash_mode
== 1731)
6486 uint
*ptr
= digest_buf
;
6488 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6489 (unsigned char *) salt
.salt_buf
,
6499 else if (hash_mode
== 1800)
6503 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6504 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6505 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6506 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6507 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6508 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6509 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6510 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6512 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6514 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6516 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6520 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6523 else if (hash_mode
== 2100)
6527 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6529 salt
.salt_iter
+ 1);
6531 uint signature_len
= strlen (out_buf
);
6533 pos
+= signature_len
;
6534 len
-= signature_len
;
6536 char *salt_ptr
= (char *) salt
.salt_buf
;
6538 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6540 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6541 byte_swap_32 (digest_buf
[0]),
6542 byte_swap_32 (digest_buf
[1]),
6543 byte_swap_32 (digest_buf
[2]),
6544 byte_swap_32 (digest_buf
[3]));
6546 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6548 memcpy (tmp_buf
, digest_buf
, 16);
6550 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6552 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6553 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6554 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6555 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6557 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6558 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6559 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6560 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6562 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6563 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6564 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6565 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6567 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6568 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6569 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6570 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6572 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6573 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6574 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6575 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6579 else if (hash_mode
== 2500)
6581 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6583 wpa_t
*wpa
= &wpas
[salt_pos
];
6585 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6586 (char *) salt
.salt_buf
,
6600 else if (hash_mode
== 4400)
6602 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6603 byte_swap_32 (digest_buf
[0]),
6604 byte_swap_32 (digest_buf
[1]),
6605 byte_swap_32 (digest_buf
[2]),
6606 byte_swap_32 (digest_buf
[3]));
6608 else if (hash_mode
== 4700)
6610 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6611 byte_swap_32 (digest_buf
[0]),
6612 byte_swap_32 (digest_buf
[1]),
6613 byte_swap_32 (digest_buf
[2]),
6614 byte_swap_32 (digest_buf
[3]),
6615 byte_swap_32 (digest_buf
[4]));
6617 else if (hash_mode
== 4800)
6619 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6621 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6626 byte_swap_32 (salt
.salt_buf
[0]),
6627 byte_swap_32 (salt
.salt_buf
[1]),
6628 byte_swap_32 (salt
.salt_buf
[2]),
6629 byte_swap_32 (salt
.salt_buf
[3]),
6632 else if (hash_mode
== 4900)
6634 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6635 byte_swap_32 (digest_buf
[0]),
6636 byte_swap_32 (digest_buf
[1]),
6637 byte_swap_32 (digest_buf
[2]),
6638 byte_swap_32 (digest_buf
[3]),
6639 byte_swap_32 (digest_buf
[4]));
6641 else if (hash_mode
== 5100)
6643 snprintf (out_buf
, len
-1, "%08x%08x",
6647 else if (hash_mode
== 5200)
6649 snprintf (out_buf
, len
-1, "%s", hashfile
);
6651 else if (hash_mode
== 5300)
6653 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6655 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6657 int buf_len
= len
-1;
6661 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6663 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6665 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6667 snprintf (out_buf
, buf_len
, ":");
6673 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6681 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6683 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6685 if ((i
== 0) || (i
== 5))
6687 snprintf (out_buf
, buf_len
, ":");
6693 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6701 for (uint i
= 0; i
< 4; i
++)
6705 snprintf (out_buf
, buf_len
, ":");
6711 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6717 else if (hash_mode
== 5400)
6719 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6721 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6723 int buf_len
= len
-1;
6727 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6729 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6731 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6733 snprintf (out_buf
, buf_len
, ":");
6739 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6747 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6749 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6751 if ((i
== 0) || (i
== 5))
6753 snprintf (out_buf
, buf_len
, ":");
6759 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6767 for (uint i
= 0; i
< 5; i
++)
6771 snprintf (out_buf
, buf_len
, ":");
6777 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6783 else if (hash_mode
== 5500)
6785 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6787 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6789 char user_buf
[64] = { 0 };
6790 char domain_buf
[64] = { 0 };
6791 char srvchall_buf
[1024] = { 0 };
6792 char clichall_buf
[1024] = { 0 };
6794 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6796 char *ptr
= (char *) netntlm
->userdomain_buf
;
6798 user_buf
[i
] = ptr
[j
];
6801 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6803 char *ptr
= (char *) netntlm
->userdomain_buf
;
6805 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6808 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6810 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6812 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6815 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6817 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6819 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6822 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6830 byte_swap_32 (salt
.salt_buf_pc
[0]),
6831 byte_swap_32 (salt
.salt_buf_pc
[1]),
6834 else if (hash_mode
== 5600)
6836 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6838 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6840 char user_buf
[64] = { 0 };
6841 char domain_buf
[64] = { 0 };
6842 char srvchall_buf
[1024] = { 0 };
6843 char clichall_buf
[1024] = { 0 };
6845 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6847 char *ptr
= (char *) netntlm
->userdomain_buf
;
6849 user_buf
[i
] = ptr
[j
];
6852 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6854 char *ptr
= (char *) netntlm
->userdomain_buf
;
6856 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6859 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6861 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6863 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6866 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6868 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6870 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6873 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6883 else if (hash_mode
== 5700)
6885 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6887 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6888 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6889 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6890 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6891 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6892 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6893 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6894 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6896 memcpy (tmp_buf
, digest_buf
, 32);
6898 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6902 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6904 else if (hash_mode
== 5800)
6906 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6907 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6908 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6909 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6910 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6912 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6919 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6921 snprintf (out_buf
, len
-1, "%s", hashfile
);
6923 else if (hash_mode
== 6300)
6925 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6927 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6928 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6929 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6930 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6932 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6934 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6936 else if (hash_mode
== 6400)
6938 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6940 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6942 else if (hash_mode
== 6500)
6944 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6946 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6948 else if (hash_mode
== 6600)
6950 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6952 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6954 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6955 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6957 uint buf_len
= len
- 1;
6959 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6962 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6964 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6969 else if (hash_mode
== 6700)
6971 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6973 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6975 else if (hash_mode
== 6800)
6977 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6979 else if (hash_mode
== 7100)
6981 uint
*ptr
= digest_buf
;
6983 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6985 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6987 uint esalt
[8] = { 0 };
6989 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6990 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6991 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6992 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6993 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6994 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6995 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6996 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6998 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",
6999 SIGNATURE_SHA512OSX
,
7001 esalt
[ 0], esalt
[ 1],
7002 esalt
[ 2], esalt
[ 3],
7003 esalt
[ 4], esalt
[ 5],
7004 esalt
[ 6], esalt
[ 7],
7012 ptr
[15], ptr
[14]);
7014 else if (hash_mode
== 7200)
7016 uint
*ptr
= digest_buf
;
7018 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7020 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7024 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7026 len_used
= strlen (out_buf
);
7028 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7030 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7032 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7035 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",
7043 ptr
[15], ptr
[14]);
7045 else if (hash_mode
== 7300)
7047 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7049 rakp_t
*rakp
= &rakps
[salt_pos
];
7051 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7053 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7056 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7063 else if (hash_mode
== 7400)
7065 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7067 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7068 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7069 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7070 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7071 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7072 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7073 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7074 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7076 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7078 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7080 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7084 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7087 else if (hash_mode
== 7500)
7089 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7091 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7093 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7094 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7096 char data
[128] = { 0 };
7098 char *ptr_data
= data
;
7100 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7102 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7105 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7107 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7112 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7114 (char *) krb5pa
->user
,
7115 (char *) krb5pa
->realm
,
7116 (char *) krb5pa
->salt
,
7119 else if (hash_mode
== 7700)
7121 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7122 (char *) salt
.salt_buf
,
7126 else if (hash_mode
== 7800)
7128 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7129 (char *) salt
.salt_buf
,
7136 else if (hash_mode
== 7900)
7138 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7142 char *tmp
= (char *) salt
.salt_buf_pc
;
7144 ptr_plain
[42] = tmp
[0];
7150 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7152 else if (hash_mode
== 8000)
7154 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7155 (unsigned char *) salt
.salt_buf
,
7165 else if (hash_mode
== 8100)
7167 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7168 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7170 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7171 (unsigned char *) salt
.salt_buf
,
7178 else if (hash_mode
== 8200)
7180 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7182 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7184 char data_buf
[4096] = { 0 };
7186 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7188 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7191 data_buf
[cloudkey
->data_len
* 2] = 0;
7193 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7194 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7195 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7196 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7197 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7198 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7199 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7200 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7202 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7203 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7204 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7205 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7207 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7223 else if (hash_mode
== 8300)
7225 char digest_buf_c
[34] = { 0 };
7227 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7228 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7229 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7230 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7231 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7233 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7235 digest_buf_c
[32] = 0;
7239 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7241 char domain_buf_c
[33] = { 0 };
7243 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7245 for (uint i
= 0; i
< salt_pc_len
; i
++)
7247 const char next
= domain_buf_c
[i
];
7249 domain_buf_c
[i
] = '.';
7254 domain_buf_c
[salt_pc_len
] = 0;
7258 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7260 else if (hash_mode
== 8500)
7262 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7264 else if (hash_mode
== 2612)
7266 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7268 (char *) salt
.salt_buf
,
7274 else if (hash_mode
== 3711)
7276 char *salt_ptr
= (char *) salt
.salt_buf
;
7278 salt_ptr
[salt
.salt_len
- 1] = 0;
7280 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7281 SIGNATURE_MEDIAWIKI_B
,
7288 else if (hash_mode
== 8800)
7290 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7292 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7294 char tmp
[3073] = { 0 };
7296 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7298 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7303 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7304 SIGNATURE_ANDROIDFDE
,
7305 byte_swap_32 (salt
.salt_buf
[0]),
7306 byte_swap_32 (salt
.salt_buf
[1]),
7307 byte_swap_32 (salt
.salt_buf
[2]),
7308 byte_swap_32 (salt
.salt_buf
[3]),
7309 byte_swap_32 (digest_buf
[0]),
7310 byte_swap_32 (digest_buf
[1]),
7311 byte_swap_32 (digest_buf
[2]),
7312 byte_swap_32 (digest_buf
[3]),
7315 else if (hash_mode
== 8900)
7317 uint N
= salt
.scrypt_N
;
7318 uint r
= salt
.scrypt_r
;
7319 uint p
= salt
.scrypt_p
;
7321 char base64_salt
[32] = { 0 };
7323 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7325 memset (tmp_buf
, 0, 46);
7327 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7328 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7329 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7330 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7331 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7332 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7333 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7334 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7335 digest_buf
[8] = 0; // needed for base64_encode ()
7337 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7339 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7347 else if (hash_mode
== 9000)
7349 snprintf (out_buf
, len
-1, "%s", hashfile
);
7351 else if (hash_mode
== 9200)
7355 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7357 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7359 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7363 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7364 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7365 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7366 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7367 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7368 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7369 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7370 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7371 digest_buf
[8] = 0; // needed for base64_encode ()
7373 char tmp_buf
[64] = { 0 };
7375 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7376 tmp_buf
[43] = 0; // cut it here
7380 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7382 else if (hash_mode
== 9300)
7384 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7385 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7386 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7387 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7388 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7389 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7390 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7391 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7392 digest_buf
[8] = 0; // needed for base64_encode ()
7394 char tmp_buf
[64] = { 0 };
7396 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7397 tmp_buf
[43] = 0; // cut it here
7399 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7401 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7403 else if (hash_mode
== 9400)
7405 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7407 office2007_t
*office2007
= &office2007s
[salt_pos
];
7409 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7410 SIGNATURE_OFFICE2007
,
7413 office2007
->keySize
,
7419 office2007
->encryptedVerifier
[0],
7420 office2007
->encryptedVerifier
[1],
7421 office2007
->encryptedVerifier
[2],
7422 office2007
->encryptedVerifier
[3],
7423 office2007
->encryptedVerifierHash
[0],
7424 office2007
->encryptedVerifierHash
[1],
7425 office2007
->encryptedVerifierHash
[2],
7426 office2007
->encryptedVerifierHash
[3],
7427 office2007
->encryptedVerifierHash
[4]);
7429 else if (hash_mode
== 9500)
7431 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7433 office2010_t
*office2010
= &office2010s
[salt_pos
];
7435 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,
7441 office2010
->encryptedVerifier
[0],
7442 office2010
->encryptedVerifier
[1],
7443 office2010
->encryptedVerifier
[2],
7444 office2010
->encryptedVerifier
[3],
7445 office2010
->encryptedVerifierHash
[0],
7446 office2010
->encryptedVerifierHash
[1],
7447 office2010
->encryptedVerifierHash
[2],
7448 office2010
->encryptedVerifierHash
[3],
7449 office2010
->encryptedVerifierHash
[4],
7450 office2010
->encryptedVerifierHash
[5],
7451 office2010
->encryptedVerifierHash
[6],
7452 office2010
->encryptedVerifierHash
[7]);
7454 else if (hash_mode
== 9600)
7456 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7458 office2013_t
*office2013
= &office2013s
[salt_pos
];
7460 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,
7466 office2013
->encryptedVerifier
[0],
7467 office2013
->encryptedVerifier
[1],
7468 office2013
->encryptedVerifier
[2],
7469 office2013
->encryptedVerifier
[3],
7470 office2013
->encryptedVerifierHash
[0],
7471 office2013
->encryptedVerifierHash
[1],
7472 office2013
->encryptedVerifierHash
[2],
7473 office2013
->encryptedVerifierHash
[3],
7474 office2013
->encryptedVerifierHash
[4],
7475 office2013
->encryptedVerifierHash
[5],
7476 office2013
->encryptedVerifierHash
[6],
7477 office2013
->encryptedVerifierHash
[7]);
7479 else if (hash_mode
== 9700)
7481 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7483 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7485 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7486 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7487 byte_swap_32 (salt
.salt_buf
[0]),
7488 byte_swap_32 (salt
.salt_buf
[1]),
7489 byte_swap_32 (salt
.salt_buf
[2]),
7490 byte_swap_32 (salt
.salt_buf
[3]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7500 else if (hash_mode
== 9710)
7502 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7504 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7506 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7507 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7508 byte_swap_32 (salt
.salt_buf
[0]),
7509 byte_swap_32 (salt
.salt_buf
[1]),
7510 byte_swap_32 (salt
.salt_buf
[2]),
7511 byte_swap_32 (salt
.salt_buf
[3]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7521 else if (hash_mode
== 9720)
7523 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7525 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7527 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7529 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7530 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7531 byte_swap_32 (salt
.salt_buf
[0]),
7532 byte_swap_32 (salt
.salt_buf
[1]),
7533 byte_swap_32 (salt
.salt_buf
[2]),
7534 byte_swap_32 (salt
.salt_buf
[3]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7549 else if (hash_mode
== 9800)
7551 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7553 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7555 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7556 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7561 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7571 else if (hash_mode
== 9810)
7573 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7575 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7577 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7578 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7583 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7593 else if (hash_mode
== 9820)
7595 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7597 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7599 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7601 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7602 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7607 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7622 else if (hash_mode
== 10000)
7626 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7628 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7630 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7634 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7635 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7636 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7637 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7638 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7639 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7640 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7641 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7642 digest_buf
[8] = 0; // needed for base64_encode ()
7644 char tmp_buf
[64] = { 0 };
7646 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7650 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7652 else if (hash_mode
== 10100)
7654 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7659 byte_swap_32 (salt
.salt_buf
[0]),
7660 byte_swap_32 (salt
.salt_buf
[1]),
7661 byte_swap_32 (salt
.salt_buf
[2]),
7662 byte_swap_32 (salt
.salt_buf
[3]));
7664 else if (hash_mode
== 10200)
7666 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7668 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7672 char challenge
[100] = { 0 };
7674 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7678 char tmp_buf
[100] = { 0 };
7680 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7681 (char *) cram_md5
->user
,
7687 char response
[100] = { 0 };
7689 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7691 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7693 else if (hash_mode
== 10300)
7695 char tmp_buf
[100] = { 0 };
7697 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7698 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7700 uint tmp_len
= 20 + salt
.salt_len
;
7704 char base64_encoded
[100] = { 0 };
7706 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7708 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7710 else if (hash_mode
== 10400)
7712 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7714 pdf_t
*pdf
= &pdfs
[salt_pos
];
7716 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",
7724 byte_swap_32 (pdf
->id_buf
[0]),
7725 byte_swap_32 (pdf
->id_buf
[1]),
7726 byte_swap_32 (pdf
->id_buf
[2]),
7727 byte_swap_32 (pdf
->id_buf
[3]),
7729 byte_swap_32 (pdf
->u_buf
[0]),
7730 byte_swap_32 (pdf
->u_buf
[1]),
7731 byte_swap_32 (pdf
->u_buf
[2]),
7732 byte_swap_32 (pdf
->u_buf
[3]),
7733 byte_swap_32 (pdf
->u_buf
[4]),
7734 byte_swap_32 (pdf
->u_buf
[5]),
7735 byte_swap_32 (pdf
->u_buf
[6]),
7736 byte_swap_32 (pdf
->u_buf
[7]),
7738 byte_swap_32 (pdf
->o_buf
[0]),
7739 byte_swap_32 (pdf
->o_buf
[1]),
7740 byte_swap_32 (pdf
->o_buf
[2]),
7741 byte_swap_32 (pdf
->o_buf
[3]),
7742 byte_swap_32 (pdf
->o_buf
[4]),
7743 byte_swap_32 (pdf
->o_buf
[5]),
7744 byte_swap_32 (pdf
->o_buf
[6]),
7745 byte_swap_32 (pdf
->o_buf
[7])
7748 else if (hash_mode
== 10410)
7750 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7752 pdf_t
*pdf
= &pdfs
[salt_pos
];
7754 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",
7762 byte_swap_32 (pdf
->id_buf
[0]),
7763 byte_swap_32 (pdf
->id_buf
[1]),
7764 byte_swap_32 (pdf
->id_buf
[2]),
7765 byte_swap_32 (pdf
->id_buf
[3]),
7767 byte_swap_32 (pdf
->u_buf
[0]),
7768 byte_swap_32 (pdf
->u_buf
[1]),
7769 byte_swap_32 (pdf
->u_buf
[2]),
7770 byte_swap_32 (pdf
->u_buf
[3]),
7771 byte_swap_32 (pdf
->u_buf
[4]),
7772 byte_swap_32 (pdf
->u_buf
[5]),
7773 byte_swap_32 (pdf
->u_buf
[6]),
7774 byte_swap_32 (pdf
->u_buf
[7]),
7776 byte_swap_32 (pdf
->o_buf
[0]),
7777 byte_swap_32 (pdf
->o_buf
[1]),
7778 byte_swap_32 (pdf
->o_buf
[2]),
7779 byte_swap_32 (pdf
->o_buf
[3]),
7780 byte_swap_32 (pdf
->o_buf
[4]),
7781 byte_swap_32 (pdf
->o_buf
[5]),
7782 byte_swap_32 (pdf
->o_buf
[6]),
7783 byte_swap_32 (pdf
->o_buf
[7])
7786 else if (hash_mode
== 10420)
7788 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7790 pdf_t
*pdf
= &pdfs
[salt_pos
];
7792 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7794 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",
7802 byte_swap_32 (pdf
->id_buf
[0]),
7803 byte_swap_32 (pdf
->id_buf
[1]),
7804 byte_swap_32 (pdf
->id_buf
[2]),
7805 byte_swap_32 (pdf
->id_buf
[3]),
7807 byte_swap_32 (pdf
->u_buf
[0]),
7808 byte_swap_32 (pdf
->u_buf
[1]),
7809 byte_swap_32 (pdf
->u_buf
[2]),
7810 byte_swap_32 (pdf
->u_buf
[3]),
7811 byte_swap_32 (pdf
->u_buf
[4]),
7812 byte_swap_32 (pdf
->u_buf
[5]),
7813 byte_swap_32 (pdf
->u_buf
[6]),
7814 byte_swap_32 (pdf
->u_buf
[7]),
7816 byte_swap_32 (pdf
->o_buf
[0]),
7817 byte_swap_32 (pdf
->o_buf
[1]),
7818 byte_swap_32 (pdf
->o_buf
[2]),
7819 byte_swap_32 (pdf
->o_buf
[3]),
7820 byte_swap_32 (pdf
->o_buf
[4]),
7821 byte_swap_32 (pdf
->o_buf
[5]),
7822 byte_swap_32 (pdf
->o_buf
[6]),
7823 byte_swap_32 (pdf
->o_buf
[7]),
7831 else if (hash_mode
== 10500)
7833 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7835 pdf_t
*pdf
= &pdfs
[salt_pos
];
7837 if (pdf
->id_len
== 32)
7839 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",
7847 byte_swap_32 (pdf
->id_buf
[0]),
7848 byte_swap_32 (pdf
->id_buf
[1]),
7849 byte_swap_32 (pdf
->id_buf
[2]),
7850 byte_swap_32 (pdf
->id_buf
[3]),
7851 byte_swap_32 (pdf
->id_buf
[4]),
7852 byte_swap_32 (pdf
->id_buf
[5]),
7853 byte_swap_32 (pdf
->id_buf
[6]),
7854 byte_swap_32 (pdf
->id_buf
[7]),
7856 byte_swap_32 (pdf
->u_buf
[0]),
7857 byte_swap_32 (pdf
->u_buf
[1]),
7858 byte_swap_32 (pdf
->u_buf
[2]),
7859 byte_swap_32 (pdf
->u_buf
[3]),
7860 byte_swap_32 (pdf
->u_buf
[4]),
7861 byte_swap_32 (pdf
->u_buf
[5]),
7862 byte_swap_32 (pdf
->u_buf
[6]),
7863 byte_swap_32 (pdf
->u_buf
[7]),
7865 byte_swap_32 (pdf
->o_buf
[0]),
7866 byte_swap_32 (pdf
->o_buf
[1]),
7867 byte_swap_32 (pdf
->o_buf
[2]),
7868 byte_swap_32 (pdf
->o_buf
[3]),
7869 byte_swap_32 (pdf
->o_buf
[4]),
7870 byte_swap_32 (pdf
->o_buf
[5]),
7871 byte_swap_32 (pdf
->o_buf
[6]),
7872 byte_swap_32 (pdf
->o_buf
[7])
7877 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",
7885 byte_swap_32 (pdf
->id_buf
[0]),
7886 byte_swap_32 (pdf
->id_buf
[1]),
7887 byte_swap_32 (pdf
->id_buf
[2]),
7888 byte_swap_32 (pdf
->id_buf
[3]),
7890 byte_swap_32 (pdf
->u_buf
[0]),
7891 byte_swap_32 (pdf
->u_buf
[1]),
7892 byte_swap_32 (pdf
->u_buf
[2]),
7893 byte_swap_32 (pdf
->u_buf
[3]),
7894 byte_swap_32 (pdf
->u_buf
[4]),
7895 byte_swap_32 (pdf
->u_buf
[5]),
7896 byte_swap_32 (pdf
->u_buf
[6]),
7897 byte_swap_32 (pdf
->u_buf
[7]),
7899 byte_swap_32 (pdf
->o_buf
[0]),
7900 byte_swap_32 (pdf
->o_buf
[1]),
7901 byte_swap_32 (pdf
->o_buf
[2]),
7902 byte_swap_32 (pdf
->o_buf
[3]),
7903 byte_swap_32 (pdf
->o_buf
[4]),
7904 byte_swap_32 (pdf
->o_buf
[5]),
7905 byte_swap_32 (pdf
->o_buf
[6]),
7906 byte_swap_32 (pdf
->o_buf
[7])
7910 else if (hash_mode
== 10600)
7912 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7914 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7915 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7917 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7919 else if (hash_mode
== 10700)
7921 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7923 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7924 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7926 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7928 else if (hash_mode
== 10900)
7930 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7932 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7933 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7935 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7937 else if (hash_mode
== 11100)
7939 u32 salt_challenge
= salt
.salt_buf
[0];
7941 salt_challenge
= byte_swap_32 (salt_challenge
);
7943 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7945 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7946 SIGNATURE_POSTGRESQL_AUTH
,
7954 else if (hash_mode
== 11200)
7956 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7957 SIGNATURE_MYSQL_AUTH
,
7958 (unsigned char *) salt
.salt_buf
,
7965 else if (hash_mode
== 11300)
7967 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7969 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7971 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7972 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7973 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7975 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7976 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7977 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7979 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7981 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7983 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7986 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7988 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7990 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7993 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7995 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7997 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8000 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8001 SIGNATURE_BITCOIN_WALLET
,
8005 (unsigned char *) salt
.salt_buf
,
8013 free (cry_master_buf
);
8015 free (public_key_buf
);
8017 else if (hash_mode
== 11400)
8019 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8021 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8022 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8024 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8026 else if (hash_mode
== 11600)
8028 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8030 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8032 const uint data_len
= seven_zip
->data_len
;
8034 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8036 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8038 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8040 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8043 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8044 SIGNATURE_SEVEN_ZIP
,
8048 (char *) seven_zip
->salt_buf
,
8050 seven_zip
->iv_buf
[0],
8051 seven_zip
->iv_buf
[1],
8052 seven_zip
->iv_buf
[2],
8053 seven_zip
->iv_buf
[3],
8055 seven_zip
->data_len
,
8056 seven_zip
->unpack_size
,
8061 else if (hash_mode
== 11700)
8063 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8073 else if (hash_mode
== 11800)
8075 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8093 else if (hash_mode
== 11900)
8095 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8097 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8098 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8100 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8102 else if (hash_mode
== 12000)
8104 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8106 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8107 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8109 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8111 else if (hash_mode
== 12100)
8113 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8115 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8116 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8118 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8120 else if (hash_mode
== 12200)
8122 uint
*ptr_digest
= digest_buf
;
8123 uint
*ptr_salt
= salt
.salt_buf
;
8125 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8132 else if (hash_mode
== 12300)
8134 uint
*ptr_digest
= digest_buf
;
8135 uint
*ptr_salt
= salt
.salt_buf
;
8137 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",
8138 ptr_digest
[ 0], ptr_digest
[ 1],
8139 ptr_digest
[ 2], ptr_digest
[ 3],
8140 ptr_digest
[ 4], ptr_digest
[ 5],
8141 ptr_digest
[ 6], ptr_digest
[ 7],
8142 ptr_digest
[ 8], ptr_digest
[ 9],
8143 ptr_digest
[10], ptr_digest
[11],
8144 ptr_digest
[12], ptr_digest
[13],
8145 ptr_digest
[14], ptr_digest
[15],
8151 else if (hash_mode
== 12400)
8153 // encode iteration count
8155 char salt_iter
[5] = { 0 };
8157 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8158 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8159 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8160 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8165 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8166 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8167 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8168 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8173 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8175 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8176 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8178 memcpy (tmp_buf
, digest_buf
, 8);
8180 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8184 // fill the resulting buffer
8186 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8188 else if (hash_mode
== 12500)
8190 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8192 byte_swap_32 (salt
.salt_buf
[0]),
8193 byte_swap_32 (salt
.salt_buf
[1]),
8199 else if (hash_mode
== 12600)
8201 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8202 digest_buf
[0] + salt
.salt_buf_pc
[0],
8203 digest_buf
[1] + salt
.salt_buf_pc
[1],
8204 digest_buf
[2] + salt
.salt_buf_pc
[2],
8205 digest_buf
[3] + salt
.salt_buf_pc
[3],
8206 digest_buf
[4] + salt
.salt_buf_pc
[4],
8207 digest_buf
[5] + salt
.salt_buf_pc
[5],
8208 digest_buf
[6] + salt
.salt_buf_pc
[6],
8209 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8211 else if (hash_mode
== 12700)
8213 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8215 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8216 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8218 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8220 else if (hash_mode
== 12800)
8222 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8224 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",
8237 byte_swap_32 (digest_buf
[0]),
8238 byte_swap_32 (digest_buf
[1]),
8239 byte_swap_32 (digest_buf
[2]),
8240 byte_swap_32 (digest_buf
[3]),
8241 byte_swap_32 (digest_buf
[4]),
8242 byte_swap_32 (digest_buf
[5]),
8243 byte_swap_32 (digest_buf
[6]),
8244 byte_swap_32 (digest_buf
[7])
8247 else if (hash_mode
== 12900)
8249 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",
8258 byte_swap_32 (digest_buf
[0]),
8259 byte_swap_32 (digest_buf
[1]),
8260 byte_swap_32 (digest_buf
[2]),
8261 byte_swap_32 (digest_buf
[3]),
8262 byte_swap_32 (digest_buf
[4]),
8263 byte_swap_32 (digest_buf
[5]),
8264 byte_swap_32 (digest_buf
[6]),
8265 byte_swap_32 (digest_buf
[7]),
8272 else if (hash_mode
== 13000)
8274 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8276 rar5_t
*rar5
= &rar5s
[salt_pos
];
8278 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8288 byte_swap_32 (digest_buf
[0]),
8289 byte_swap_32 (digest_buf
[1])
8292 else if (hash_mode
== 13100)
8294 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8296 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8298 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8299 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8301 char data
[2560 * 4 * 2] = { 0 };
8303 char *ptr_data
= data
;
8305 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8306 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8311 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8312 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8314 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8316 (char *) krb5tgs
->account_info
,
8320 else if (hash_mode
== 13200)
8322 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8336 else if (hash_mode
== 13300)
8338 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8339 SIGNATURE_AXCRYPT_SHA1
,
8345 else if (hash_mode
== 13400)
8347 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8349 keepass_t
*keepass
= &keepasss
[salt_pos
];
8351 u32 version
= (u32
) keepass
->version
;
8352 u32 rounds
= salt
.salt_iter
;
8353 u32 algorithm
= (u32
) keepass
->algorithm
;
8354 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8356 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8357 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8358 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8359 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8360 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8362 /* specific to version 1 */
8366 /* specific to version 2 */
8367 u32 expected_bytes_len
;
8368 u32
*ptr_expected_bytes
;
8370 u32 final_random_seed_len
;
8371 u32 transf_random_seed_len
;
8373 u32 contents_hash_len
;
8375 transf_random_seed_len
= 8;
8377 contents_hash_len
= 8;
8378 final_random_seed_len
= 8;
8381 final_random_seed_len
= 4;
8383 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8389 char *ptr_data
= out_buf
;
8391 ptr_data
+= strlen(out_buf
);
8396 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8397 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8402 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8403 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8408 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8409 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8416 contents_len
= (u32
) keepass
->contents_len
;
8417 ptr_contents
= (u32
*) keepass
->contents
;
8419 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8420 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8432 char ptr_contents_len
[10] = { 0 };
8434 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8436 sprintf (ptr_data
, "%d", contents_len
);
8438 ptr_data
+= strlen(ptr_contents_len
);
8443 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8444 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8446 else if (version
== 2)
8448 expected_bytes_len
= 8;
8449 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8451 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8452 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8457 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8458 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8472 sprintf (ptr_data
, "%d", keyfile_len
);
8479 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8480 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8483 else if (hash_mode
== 13500)
8485 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8486 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8488 uint mysalt
= pstoken
->salt_len
> 512 ? 512 : pstoken
->salt_len
;
8490 char pstoken_tmp
[1024 + 1];
8491 u8
*salt_buf_ptr
= (u8
*) pstoken
->salt_buf
;
8493 memset(pstoken_tmp
, 0, sizeof (pstoken_tmp
));
8495 for (uint i
= 0; i
< mysalt
; i
++)
8497 snprintf(&pstoken_tmp
[i
*2], 2, "%02x", salt_buf_ptr
[i
]);
8500 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8510 if (hash_type
== HASH_TYPE_MD4
)
8512 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8518 else if (hash_type
== HASH_TYPE_MD5
)
8520 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8526 else if (hash_type
== HASH_TYPE_SHA1
)
8528 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8535 else if (hash_type
== HASH_TYPE_SHA256
)
8537 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8547 else if (hash_type
== HASH_TYPE_SHA384
)
8549 uint
*ptr
= digest_buf
;
8551 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8559 else if (hash_type
== HASH_TYPE_SHA512
)
8561 uint
*ptr
= digest_buf
;
8563 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8573 else if (hash_type
== HASH_TYPE_LM
)
8575 snprintf (out_buf
, len
-1, "%08x%08x",
8579 else if (hash_type
== HASH_TYPE_ORACLEH
)
8581 snprintf (out_buf
, len
-1, "%08X%08X",
8585 else if (hash_type
== HASH_TYPE_BCRYPT
)
8587 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8588 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8590 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8592 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8594 else if (hash_type
== HASH_TYPE_KECCAK
)
8596 uint
*ptr
= digest_buf
;
8598 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",
8626 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8628 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8630 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8637 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8639 digest_buf
[ 0] = digest_buf
[ 0];
8640 digest_buf
[ 1] = digest_buf
[ 1];
8641 digest_buf
[ 2] = digest_buf
[ 2];
8642 digest_buf
[ 3] = digest_buf
[ 3];
8643 digest_buf
[ 4] = digest_buf
[ 4];
8644 digest_buf
[ 5] = digest_buf
[ 5];
8645 digest_buf
[ 6] = digest_buf
[ 6];
8646 digest_buf
[ 7] = digest_buf
[ 7];
8647 digest_buf
[ 8] = digest_buf
[ 8];
8648 digest_buf
[ 9] = digest_buf
[ 9];
8649 digest_buf
[10] = digest_buf
[10];
8650 digest_buf
[11] = digest_buf
[11];
8651 digest_buf
[12] = digest_buf
[12];
8652 digest_buf
[13] = digest_buf
[13];
8653 digest_buf
[14] = digest_buf
[14];
8654 digest_buf
[15] = digest_buf
[15];
8656 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8674 else if (hash_type
== HASH_TYPE_GOST
)
8676 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8686 else if (hash_type
== HASH_TYPE_MYSQL
)
8688 snprintf (out_buf
, len
-1, "%08x%08x",
8692 else if (hash_type
== HASH_TYPE_LOTUS5
)
8694 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8700 else if (hash_type
== HASH_TYPE_LOTUS6
)
8702 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8703 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8704 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8705 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8707 char buf
[16] = { 0 };
8709 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8710 memcpy (buf
+ 5, digest_buf
, 9);
8714 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8716 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8719 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8721 else if (hash_type
== HASH_TYPE_LOTUS8
)
8723 char buf
[52] = { 0 };
8727 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8733 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8737 buf
[26] = salt
.salt_buf_pc
[0];
8738 buf
[27] = salt
.salt_buf_pc
[1];
8742 memcpy (buf
+ 28, digest_buf
, 8);
8744 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8748 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8750 else if (hash_type
== HASH_TYPE_CRC32
)
8752 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8756 if (salt_type
== SALT_TYPE_INTERN
)
8758 size_t pos
= strlen (out_buf
);
8760 out_buf
[pos
] = data
.separator
;
8762 char *ptr
= (char *) salt
.salt_buf
;
8764 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8766 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8770 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8772 memset (hccap
, 0, sizeof (hccap_t
));
8774 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8776 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8778 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8779 wpa_t
*wpa
= &wpas
[salt_pos
];
8781 hccap
->keyver
= wpa
->keyver
;
8783 hccap
->eapol_size
= wpa
->eapol_size
;
8785 if (wpa
->keyver
!= 1)
8787 uint eapol_tmp
[64] = { 0 };
8789 for (uint i
= 0; i
< 64; i
++)
8791 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8794 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8798 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8801 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8802 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8803 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8804 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8806 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8808 uint dgst_size
= data
.dgst_size
;
8810 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8812 if (wpa
->keyver
!= 1)
8814 uint digest_tmp
[4] = { 0 };
8816 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8817 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8818 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8819 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8821 memcpy (hccap
->keymic
, digest_tmp
, 16);
8825 memcpy (hccap
->keymic
, digest_ptr
, 16);
8829 void SuspendThreads ()
8831 if (data
.devices_status
== STATUS_RUNNING
)
8833 hc_timer_set (&data
.timer_paused
);
8835 data
.devices_status
= STATUS_PAUSED
;
8837 log_info ("Paused");
8841 void ResumeThreads ()
8843 if (data
.devices_status
== STATUS_PAUSED
)
8847 hc_timer_get (data
.timer_paused
, ms_paused
);
8849 data
.ms_paused
+= ms_paused
;
8851 data
.devices_status
= STATUS_RUNNING
;
8853 log_info ("Resumed");
8859 if (data
.devices_status
!= STATUS_RUNNING
) return;
8861 data
.devices_status
= STATUS_BYPASS
;
8863 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8866 void stop_at_checkpoint ()
8868 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8870 if (data
.devices_status
!= STATUS_RUNNING
) return;
8873 // this feature only makes sense if --restore-disable was not specified
8875 if (data
.restore_disable
== 1)
8877 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8882 // check if monitoring of Restore Point updates should be enabled or disabled
8884 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8886 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8888 // save the current restore point value
8890 data
.checkpoint_cur_words
= get_lowest_words_done ();
8892 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8896 data
.devices_status
= STATUS_RUNNING
;
8898 // reset the global value for checkpoint checks
8900 data
.checkpoint_cur_words
= 0;
8902 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8908 if (data
.devices_status
== STATUS_INIT
) return;
8909 if (data
.devices_status
== STATUS_STARTING
) return;
8911 data
.devices_status
= STATUS_ABORTED
;
8916 if (data
.devices_status
== STATUS_INIT
) return;
8917 if (data
.devices_status
== STATUS_STARTING
) return;
8919 data
.devices_status
= STATUS_QUIT
;
8922 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8924 FILE *fp
= fopen (kernel_file
, "rb");
8930 memset (&st
, 0, sizeof (st
));
8932 stat (kernel_file
, &st
);
8934 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8936 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8938 if (num_read
!= (size_t) st
.st_size
)
8940 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8947 buf
[st
.st_size
] = 0;
8949 for (int i
= 0; i
< num_devices
; i
++)
8951 kernel_lengths
[i
] = (size_t) st
.st_size
;
8953 kernel_sources
[i
] = buf
;
8958 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8966 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8968 if (binary_size
> 0)
8970 FILE *fp
= fopen (dst
, "wb");
8973 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8984 restore_data_t
*init_restore (int argc
, char **argv
)
8986 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8988 if (data
.restore_disable
== 0)
8990 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8994 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8998 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9007 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9009 int pidbin_len
= -1;
9012 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9014 FILE *fd
= fopen (pidbin
, "rb");
9018 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9020 pidbin
[pidbin_len
] = 0;
9024 char *argv0_r
= strrchr (argv
[0], '/');
9026 char *pidbin_r
= strrchr (pidbin
, '/');
9028 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9030 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9032 if (strcmp (argv0_r
, pidbin_r
) == 0)
9034 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9041 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9043 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9045 int pidbin2_len
= -1;
9047 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9048 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9050 pidbin
[pidbin_len
] = 0;
9051 pidbin2
[pidbin2_len
] = 0;
9055 if (strcmp (pidbin
, pidbin2
) == 0)
9057 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9070 if (rd
->version_bin
< RESTORE_MIN
)
9072 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9079 memset (rd
, 0, sizeof (restore_data_t
));
9081 rd
->version_bin
= VERSION_BIN
;
9084 rd
->pid
= getpid ();
9086 rd
->pid
= GetCurrentProcessId ();
9089 if (getcwd (rd
->cwd
, 255) == NULL
)
9102 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9104 FILE *fp
= fopen (eff_restore_file
, "rb");
9108 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9113 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9115 log_error ("ERROR: cannot read %s", eff_restore_file
);
9120 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9122 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9124 for (uint i
= 0; i
< rd
->argc
; i
++)
9126 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9128 log_error ("ERROR: cannot read %s", eff_restore_file
);
9133 size_t len
= strlen (buf
);
9135 if (len
) buf
[len
- 1] = 0;
9137 rd
->argv
[i
] = mystrdup (buf
);
9144 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9146 if (chdir (rd
->cwd
))
9148 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9149 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9150 " https://github.com/philsmd/analyze_hc_restore\n"
9151 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9157 u64
get_lowest_words_done ()
9161 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9163 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9165 if (device_param
->skipped
) continue;
9167 const u64 words_done
= device_param
->words_done
;
9169 if (words_done
< words_cur
) words_cur
= words_done
;
9172 // It's possible that a device's workload isn't finished right after a restore-case.
9173 // In that case, this function would return 0 and overwrite the real restore point
9174 // There's also data.words_cur which is set to rd->words_cur but it changes while
9175 // the attack is running therefore we should stick to rd->words_cur.
9176 // Note that -s influences rd->words_cur we should keep a close look on that.
9178 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9183 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9185 u64 words_cur
= get_lowest_words_done ();
9187 rd
->words_cur
= words_cur
;
9189 FILE *fp
= fopen (new_restore_file
, "wb");
9193 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9198 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9200 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9205 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9207 for (uint i
= 0; i
< rd
->argc
; i
++)
9209 fprintf (fp
, "%s", rd
->argv
[i
]);
9215 fsync (fileno (fp
));
9220 void cycle_restore ()
9222 const char *eff_restore_file
= data
.eff_restore_file
;
9223 const char *new_restore_file
= data
.new_restore_file
;
9225 restore_data_t
*rd
= data
.rd
;
9227 write_restore (new_restore_file
, rd
);
9231 memset (&st
, 0, sizeof(st
));
9233 if (stat (eff_restore_file
, &st
) == 0)
9235 if (unlink (eff_restore_file
))
9237 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9241 if (rename (new_restore_file
, eff_restore_file
))
9243 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9247 void check_checkpoint ()
9249 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9251 u64 words_cur
= get_lowest_words_done ();
9253 if (words_cur
!= data
.checkpoint_cur_words
)
9263 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9267 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9269 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9271 myfree (alias
->device_name
);
9272 myfree (alias
->alias_name
);
9275 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9277 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9279 myfree (entry
->device_name
);
9282 myfree (tuning_db
->alias_buf
);
9283 myfree (tuning_db
->entry_buf
);
9288 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9290 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9292 int num_lines
= count_lines (fp
);
9294 // a bit over-allocated
9296 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9297 tuning_db
->alias_cnt
= 0;
9299 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9300 tuning_db
->entry_cnt
= 0;
9305 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9307 FILE *fp
= fopen (tuning_db_file
, "rb");
9311 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9316 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9322 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9326 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9328 if (line_buf
== NULL
) break;
9332 const int line_len
= in_superchop (line_buf
);
9334 if (line_len
== 0) continue;
9336 if (line_buf
[0] == '#') continue;
9340 char *token_ptr
[7] = { NULL
};
9344 char *next
= strtok (line_buf
, "\t ");
9346 token_ptr
[token_cnt
] = next
;
9350 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9352 token_ptr
[token_cnt
] = next
;
9359 char *device_name
= token_ptr
[0];
9360 char *alias_name
= token_ptr
[1];
9362 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9364 alias
->device_name
= mystrdup (device_name
);
9365 alias
->alias_name
= mystrdup (alias_name
);
9367 tuning_db
->alias_cnt
++;
9369 else if (token_cnt
== 6)
9371 if ((token_ptr
[1][0] != '0') &&
9372 (token_ptr
[1][0] != '1') &&
9373 (token_ptr
[1][0] != '3') &&
9374 (token_ptr
[1][0] != '*'))
9376 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9381 if ((token_ptr
[3][0] != '1') &&
9382 (token_ptr
[3][0] != '2') &&
9383 (token_ptr
[3][0] != '4') &&
9384 (token_ptr
[3][0] != '8') &&
9385 (token_ptr
[3][0] != 'N'))
9387 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9392 char *device_name
= token_ptr
[0];
9394 int attack_mode
= -1;
9396 int vector_width
= -1;
9397 int kernel_accel
= -1;
9398 int kernel_loops
= -1;
9400 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9401 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9402 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9404 if (token_ptr
[4][0] != 'A')
9406 kernel_accel
= atoi (token_ptr
[4]);
9408 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9410 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9420 if (token_ptr
[5][0] != 'A')
9422 kernel_loops
= atoi (token_ptr
[5]);
9424 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9426 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9436 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9438 entry
->device_name
= mystrdup (device_name
);
9439 entry
->attack_mode
= attack_mode
;
9440 entry
->hash_type
= hash_type
;
9441 entry
->vector_width
= vector_width
;
9442 entry
->kernel_accel
= kernel_accel
;
9443 entry
->kernel_loops
= kernel_loops
;
9445 tuning_db
->entry_cnt
++;
9449 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9459 // todo: print loaded 'cnt' message
9461 // sort the database
9463 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9464 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9469 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9471 static tuning_db_entry_t s
;
9473 // first we need to convert all spaces in the device_name to underscore
9475 char *device_name_nospace
= strdup (device_param
->device_name
);
9477 int device_name_length
= strlen (device_name_nospace
);
9481 for (i
= 0; i
< device_name_length
; i
++)
9483 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9486 // find out if there's an alias configured
9488 tuning_db_alias_t a
;
9490 a
.device_name
= device_name_nospace
;
9492 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
);
9494 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9496 // attack-mode 6 and 7 are attack-mode 1 basically
9498 if (attack_mode
== 6) attack_mode
= 1;
9499 if (attack_mode
== 7) attack_mode
= 1;
9501 // bsearch is not ideal but fast enough
9503 s
.device_name
= device_name_nospace
;
9504 s
.attack_mode
= attack_mode
;
9505 s
.hash_type
= hash_type
;
9507 tuning_db_entry_t
*entry
= NULL
;
9509 // this will produce all 2^3 combinations required
9511 for (i
= 0; i
< 8; i
++)
9513 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9514 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9515 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9517 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9519 if (entry
!= NULL
) break;
9521 // in non-wildcard mode do some additional checks:
9525 // in case we have an alias-name
9527 if (alias_name
!= NULL
)
9529 s
.device_name
= alias_name
;
9531 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9533 if (entry
!= NULL
) break;
9536 // or by device type
9538 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9540 s
.device_name
= "DEVICE_TYPE_CPU";
9542 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9544 s
.device_name
= "DEVICE_TYPE_GPU";
9546 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9548 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9551 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9553 if (entry
!= NULL
) break;
9557 // free converted device_name
9559 myfree (device_name_nospace
);
9568 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9570 u8 tmp
[256] = { 0 };
9572 if (salt_len
> sizeof (tmp
))
9577 memcpy (tmp
, in
, salt_len
);
9579 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9581 if ((salt_len
% 2) == 0)
9583 u32 new_salt_len
= salt_len
/ 2;
9585 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9590 tmp
[i
] = hex_convert (p1
) << 0;
9591 tmp
[i
] |= hex_convert (p0
) << 4;
9594 salt_len
= new_salt_len
;
9601 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9603 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9606 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9608 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9612 u32
*tmp_uint
= (u32
*) tmp
;
9614 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9615 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9616 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9617 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9618 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9619 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9620 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9621 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9622 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9623 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9625 salt_len
= salt_len
* 2;
9633 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9635 lowercase (tmp
, salt_len
);
9638 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9640 uppercase (tmp
, salt_len
);
9645 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9650 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9655 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9657 u32
*tmp_uint
= (uint
*) tmp
;
9663 for (u32 i
= 0; i
< max
; i
++)
9665 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9668 // Important: we may need to increase the length of memcpy since
9669 // we don't want to "loose" some swapped bytes (could happen if
9670 // they do not perfectly fit in the 4-byte blocks)
9671 // Memcpy does always copy the bytes in the BE order, but since
9672 // we swapped them, some important bytes could be in positions
9673 // we normally skip with the original len
9675 if (len
% 4) len
+= 4 - (len
% 4);
9678 memcpy (out
, tmp
, len
);
9683 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9685 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9687 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9689 u32
*digest
= (u32
*) hash_buf
->digest
;
9691 salt_t
*salt
= hash_buf
->salt
;
9693 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9695 char *iter_pos
= input_buf
+ 4;
9697 salt
->salt_iter
= 1 << atoi (iter_pos
);
9699 char *salt_pos
= strchr (iter_pos
, '$');
9701 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9707 salt
->salt_len
= salt_len
;
9709 u8 tmp_buf
[100] = { 0 };
9711 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9713 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9715 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9717 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9718 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9719 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9720 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9722 char *hash_pos
= salt_pos
+ 22;
9724 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9726 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9728 memcpy (digest
, tmp_buf
, 24);
9730 digest
[0] = byte_swap_32 (digest
[0]);
9731 digest
[1] = byte_swap_32 (digest
[1]);
9732 digest
[2] = byte_swap_32 (digest
[2]);
9733 digest
[3] = byte_swap_32 (digest
[3]);
9734 digest
[4] = byte_swap_32 (digest
[4]);
9735 digest
[5] = byte_swap_32 (digest
[5]);
9737 digest
[5] &= ~0xff; // its just 23 not 24 !
9742 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9744 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9746 u32
*digest
= (u32
*) hash_buf
->digest
;
9748 u8 tmp_buf
[100] = { 0 };
9750 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9752 memcpy (digest
, tmp_buf
, 32);
9754 digest
[0] = byte_swap_32 (digest
[0]);
9755 digest
[1] = byte_swap_32 (digest
[1]);
9756 digest
[2] = byte_swap_32 (digest
[2]);
9757 digest
[3] = byte_swap_32 (digest
[3]);
9758 digest
[4] = byte_swap_32 (digest
[4]);
9759 digest
[5] = byte_swap_32 (digest
[5]);
9760 digest
[6] = byte_swap_32 (digest
[6]);
9761 digest
[7] = byte_swap_32 (digest
[7]);
9763 digest
[0] -= SHA256M_A
;
9764 digest
[1] -= SHA256M_B
;
9765 digest
[2] -= SHA256M_C
;
9766 digest
[3] -= SHA256M_D
;
9767 digest
[4] -= SHA256M_E
;
9768 digest
[5] -= SHA256M_F
;
9769 digest
[6] -= SHA256M_G
;
9770 digest
[7] -= SHA256M_H
;
9775 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9777 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9779 u32
*digest
= (u32
*) hash_buf
->digest
;
9781 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9782 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9784 digest
[0] = byte_swap_32 (digest
[0]);
9785 digest
[1] = byte_swap_32 (digest
[1]);
9789 IP (digest
[0], digest
[1], tt
);
9791 digest
[0] = digest
[0];
9792 digest
[1] = digest
[1];
9799 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9801 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9803 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9805 u32
*digest
= (u32
*) hash_buf
->digest
;
9807 salt_t
*salt
= hash_buf
->salt
;
9809 char *hash_pos
= input_buf
+ 10;
9811 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9812 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9813 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9814 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9815 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9817 digest
[0] -= SHA1M_A
;
9818 digest
[1] -= SHA1M_B
;
9819 digest
[2] -= SHA1M_C
;
9820 digest
[3] -= SHA1M_D
;
9821 digest
[4] -= SHA1M_E
;
9825 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9827 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9829 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9831 salt
->salt_len
= salt_len
;
9836 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9838 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9840 u32
*digest
= (u32
*) hash_buf
->digest
;
9842 salt_t
*salt
= hash_buf
->salt
;
9844 char *hash_pos
= input_buf
+ 8;
9846 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9847 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9848 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9849 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9850 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9852 digest
[0] -= SHA1M_A
;
9853 digest
[1] -= SHA1M_B
;
9854 digest
[2] -= SHA1M_C
;
9855 digest
[3] -= SHA1M_D
;
9856 digest
[4] -= SHA1M_E
;
9860 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9862 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9864 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9866 salt
->salt_len
= salt_len
;
9871 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9873 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9875 u64
*digest
= (u64
*) hash_buf
->digest
;
9877 salt_t
*salt
= hash_buf
->salt
;
9879 char *hash_pos
= input_buf
+ 8;
9881 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9882 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9883 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9884 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9885 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9886 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9887 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9888 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9890 digest
[0] -= SHA512M_A
;
9891 digest
[1] -= SHA512M_B
;
9892 digest
[2] -= SHA512M_C
;
9893 digest
[3] -= SHA512M_D
;
9894 digest
[4] -= SHA512M_E
;
9895 digest
[5] -= SHA512M_F
;
9896 digest
[6] -= SHA512M_G
;
9897 digest
[7] -= SHA512M_H
;
9901 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9903 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9905 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9907 salt
->salt_len
= salt_len
;
9912 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9914 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9916 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9920 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9923 u32
*digest
= (u32
*) hash_buf
->digest
;
9925 salt_t
*salt
= hash_buf
->salt
;
9927 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9928 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9929 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9930 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9932 digest
[0] = byte_swap_32 (digest
[0]);
9933 digest
[1] = byte_swap_32 (digest
[1]);
9934 digest
[2] = byte_swap_32 (digest
[2]);
9935 digest
[3] = byte_swap_32 (digest
[3]);
9937 digest
[0] -= MD5M_A
;
9938 digest
[1] -= MD5M_B
;
9939 digest
[2] -= MD5M_C
;
9940 digest
[3] -= MD5M_D
;
9942 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9944 uint salt_len
= input_len
- 32 - 1;
9946 char *salt_buf
= input_buf
+ 32 + 1;
9948 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9950 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9952 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9954 salt
->salt_len
= salt_len
;
9959 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9961 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9963 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9967 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9972 char clean_input_buf
[32] = { 0 };
9974 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9975 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9977 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9981 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9987 clean_input_buf
[k
] = input_buf
[i
];
9995 u32
*digest
= (u32
*) hash_buf
->digest
;
9997 salt_t
*salt
= hash_buf
->salt
;
9999 u32 a
, b
, c
, d
, e
, f
;
10001 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10002 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10003 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10004 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10005 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10006 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10008 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10009 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10011 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10012 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10013 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10014 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10015 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10016 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10018 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10019 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10021 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10022 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10023 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10024 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10025 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10026 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10028 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10029 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10031 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10032 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10033 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10034 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10035 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10036 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10038 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10039 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10041 digest
[0] = byte_swap_32 (digest
[0]);
10042 digest
[1] = byte_swap_32 (digest
[1]);
10043 digest
[2] = byte_swap_32 (digest
[2]);
10044 digest
[3] = byte_swap_32 (digest
[3]);
10046 digest
[0] -= MD5M_A
;
10047 digest
[1] -= MD5M_B
;
10048 digest
[2] -= MD5M_C
;
10049 digest
[3] -= MD5M_D
;
10051 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10053 uint salt_len
= input_len
- 30 - 1;
10055 char *salt_buf
= input_buf
+ 30 + 1;
10057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10059 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10061 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10062 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10064 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10066 salt
->salt_len
= salt_len
;
10068 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10070 salt
->salt_len
+= 22;
10072 return (PARSER_OK
);
10075 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10077 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10079 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10083 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10086 u32
*digest
= (u32
*) hash_buf
->digest
;
10088 salt_t
*salt
= hash_buf
->salt
;
10090 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10091 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10092 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10093 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10094 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10096 digest
[0] -= SHA1M_A
;
10097 digest
[1] -= SHA1M_B
;
10098 digest
[2] -= SHA1M_C
;
10099 digest
[3] -= SHA1M_D
;
10100 digest
[4] -= SHA1M_E
;
10102 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10104 uint salt_len
= input_len
- 40 - 1;
10106 char *salt_buf
= input_buf
+ 40 + 1;
10108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10114 salt
->salt_len
= salt_len
;
10116 return (PARSER_OK
);
10119 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10121 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10123 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10127 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10130 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10132 char *iter_pos
= input_buf
+ 6;
10134 salt_t
*salt
= hash_buf
->salt
;
10136 uint iter
= atoi (iter_pos
);
10140 iter
= ROUNDS_DCC2
;
10143 salt
->salt_iter
= iter
- 1;
10145 char *salt_pos
= strchr (iter_pos
, '#');
10147 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10151 char *digest_pos
= strchr (salt_pos
, '#');
10153 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10157 uint salt_len
= digest_pos
- salt_pos
- 1;
10159 u32
*digest
= (u32
*) hash_buf
->digest
;
10161 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10162 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10163 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10164 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10166 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10168 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10170 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10172 salt
->salt_len
= salt_len
;
10174 return (PARSER_OK
);
10177 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10179 u32
*digest
= (u32
*) hash_buf
->digest
;
10181 salt_t
*salt
= hash_buf
->salt
;
10183 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10187 memcpy (&in
, input_buf
, input_len
);
10189 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10191 memcpy (digest
, in
.keymic
, 16);
10194 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10195 The phrase "Pairwise key expansion"
10196 Access Point Address (referred to as Authenticator Address AA)
10197 Supplicant Address (referred to as Supplicant Address SA)
10198 Access Point Nonce (referred to as Authenticator Anonce)
10199 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10202 uint salt_len
= strlen (in
.essid
);
10206 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10208 return (PARSER_SALT_LENGTH
);
10211 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10213 salt
->salt_len
= salt_len
;
10215 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10217 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10219 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10221 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10223 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10224 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10228 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10229 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10232 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10234 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10235 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10239 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10240 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10243 for (int i
= 0; i
< 25; i
++)
10245 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10248 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10249 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10250 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10251 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10253 wpa
->keyver
= in
.keyver
;
10255 if (wpa
->keyver
> 255)
10257 log_info ("ATTENTION!");
10258 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10259 log_info (" This could be due to a recent aircrack-ng bug.");
10260 log_info (" The key version was automatically reset to a reasonable value.");
10263 wpa
->keyver
&= 0xff;
10266 wpa
->eapol_size
= in
.eapol_size
;
10268 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10270 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10272 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10274 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10276 if (wpa
->keyver
== 1)
10282 digest
[0] = byte_swap_32 (digest
[0]);
10283 digest
[1] = byte_swap_32 (digest
[1]);
10284 digest
[2] = byte_swap_32 (digest
[2]);
10285 digest
[3] = byte_swap_32 (digest
[3]);
10287 for (int i
= 0; i
< 64; i
++)
10289 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10293 uint32_t *p0
= (uint32_t *) in
.essid
;
10297 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10298 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10300 salt
->salt_buf
[10] = c0
;
10301 salt
->salt_buf
[11] = c1
;
10303 return (PARSER_OK
);
10306 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10308 u32
*digest
= (u32
*) hash_buf
->digest
;
10310 salt_t
*salt
= hash_buf
->salt
;
10312 if (input_len
== 0)
10314 log_error ("Password Safe v2 container not specified");
10319 FILE *fp
= fopen (input_buf
, "rb");
10323 log_error ("%s: %s", input_buf
, strerror (errno
));
10330 memset (&buf
, 0, sizeof (psafe2_hdr
));
10332 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10336 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10338 salt
->salt_buf
[0] = buf
.random
[0];
10339 salt
->salt_buf
[1] = buf
.random
[1];
10341 salt
->salt_len
= 8;
10342 salt
->salt_iter
= 1000;
10344 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10345 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10346 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10347 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10348 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10350 return (PARSER_OK
);
10353 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10355 u32
*digest
= (u32
*) hash_buf
->digest
;
10357 salt_t
*salt
= hash_buf
->salt
;
10359 if (input_len
== 0)
10361 log_error (".psafe3 not specified");
10366 FILE *fp
= fopen (input_buf
, "rb");
10370 log_error ("%s: %s", input_buf
, strerror (errno
));
10377 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10381 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10383 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10385 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10387 salt
->salt_iter
= in
.iterations
+ 1;
10389 salt
->salt_buf
[0] = in
.salt_buf
[0];
10390 salt
->salt_buf
[1] = in
.salt_buf
[1];
10391 salt
->salt_buf
[2] = in
.salt_buf
[2];
10392 salt
->salt_buf
[3] = in
.salt_buf
[3];
10393 salt
->salt_buf
[4] = in
.salt_buf
[4];
10394 salt
->salt_buf
[5] = in
.salt_buf
[5];
10395 salt
->salt_buf
[6] = in
.salt_buf
[6];
10396 salt
->salt_buf
[7] = in
.salt_buf
[7];
10398 salt
->salt_len
= 32;
10400 digest
[0] = in
.hash_buf
[0];
10401 digest
[1] = in
.hash_buf
[1];
10402 digest
[2] = in
.hash_buf
[2];
10403 digest
[3] = in
.hash_buf
[3];
10404 digest
[4] = in
.hash_buf
[4];
10405 digest
[5] = in
.hash_buf
[5];
10406 digest
[6] = in
.hash_buf
[6];
10407 digest
[7] = in
.hash_buf
[7];
10409 digest
[0] = byte_swap_32 (digest
[0]);
10410 digest
[1] = byte_swap_32 (digest
[1]);
10411 digest
[2] = byte_swap_32 (digest
[2]);
10412 digest
[3] = byte_swap_32 (digest
[3]);
10413 digest
[4] = byte_swap_32 (digest
[4]);
10414 digest
[5] = byte_swap_32 (digest
[5]);
10415 digest
[6] = byte_swap_32 (digest
[6]);
10416 digest
[7] = byte_swap_32 (digest
[7]);
10418 return (PARSER_OK
);
10421 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10423 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10425 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10427 u32
*digest
= (u32
*) hash_buf
->digest
;
10429 salt_t
*salt
= hash_buf
->salt
;
10431 char *iter_pos
= input_buf
+ 3;
10433 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10435 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10437 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10439 salt
->salt_iter
= salt_iter
;
10441 char *salt_pos
= iter_pos
+ 1;
10445 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10447 salt
->salt_len
= salt_len
;
10449 char *hash_pos
= salt_pos
+ salt_len
;
10451 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10453 return (PARSER_OK
);
10456 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10458 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10460 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10462 u32
*digest
= (u32
*) hash_buf
->digest
;
10464 salt_t
*salt
= hash_buf
->salt
;
10466 char *salt_pos
= input_buf
+ 3;
10468 uint iterations_len
= 0;
10470 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10474 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10476 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10477 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10481 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10485 iterations_len
+= 8;
10489 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10492 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10494 char *hash_pos
= strchr (salt_pos
, '$');
10496 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10498 uint salt_len
= hash_pos
- salt_pos
;
10500 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10502 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10504 salt
->salt_len
= salt_len
;
10508 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10510 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10512 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10514 return (PARSER_OK
);
10517 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10519 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10521 u32
*digest
= (u32
*) hash_buf
->digest
;
10523 salt_t
*salt
= hash_buf
->salt
;
10525 char *salt_pos
= input_buf
+ 6;
10527 uint iterations_len
= 0;
10529 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10533 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10535 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10536 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10540 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10544 iterations_len
+= 8;
10548 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10551 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10553 char *hash_pos
= strchr (salt_pos
, '$');
10555 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10557 uint salt_len
= hash_pos
- salt_pos
;
10559 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10561 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10563 salt
->salt_len
= salt_len
;
10567 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10569 return (PARSER_OK
);
10572 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10574 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10576 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10578 u32
*digest
= (u32
*) hash_buf
->digest
;
10580 salt_t
*salt
= hash_buf
->salt
;
10582 char *salt_pos
= input_buf
+ 14;
10584 char *hash_pos
= strchr (salt_pos
, '*');
10586 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10590 uint salt_len
= hash_pos
- salt_pos
- 1;
10592 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10594 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10596 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10598 salt
->salt_len
= salt_len
;
10600 u8 tmp_buf
[100] = { 0 };
10602 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10604 memcpy (digest
, tmp_buf
, 20);
10606 digest
[0] = byte_swap_32 (digest
[0]);
10607 digest
[1] = byte_swap_32 (digest
[1]);
10608 digest
[2] = byte_swap_32 (digest
[2]);
10609 digest
[3] = byte_swap_32 (digest
[3]);
10610 digest
[4] = byte_swap_32 (digest
[4]);
10612 digest
[0] -= SHA1M_A
;
10613 digest
[1] -= SHA1M_B
;
10614 digest
[2] -= SHA1M_C
;
10615 digest
[3] -= SHA1M_D
;
10616 digest
[4] -= SHA1M_E
;
10618 return (PARSER_OK
);
10621 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10623 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10625 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10627 if (c12
& 3) return (PARSER_HASH_VALUE
);
10629 u32
*digest
= (u32
*) hash_buf
->digest
;
10631 salt_t
*salt
= hash_buf
->salt
;
10633 // for ascii_digest
10634 salt
->salt_sign
[0] = input_buf
[0];
10635 salt
->salt_sign
[1] = input_buf
[1];
10637 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10638 | itoa64_to_int (input_buf
[1]) << 6;
10640 salt
->salt_len
= 2;
10642 u8 tmp_buf
[100] = { 0 };
10644 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10646 memcpy (digest
, tmp_buf
, 8);
10650 IP (digest
[0], digest
[1], tt
);
10655 return (PARSER_OK
);
10658 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10660 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10662 u32
*digest
= (u32
*) hash_buf
->digest
;
10664 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10665 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10666 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10667 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10669 digest
[0] = byte_swap_32 (digest
[0]);
10670 digest
[1] = byte_swap_32 (digest
[1]);
10671 digest
[2] = byte_swap_32 (digest
[2]);
10672 digest
[3] = byte_swap_32 (digest
[3]);
10674 digest
[0] -= MD4M_A
;
10675 digest
[1] -= MD4M_B
;
10676 digest
[2] -= MD4M_C
;
10677 digest
[3] -= MD4M_D
;
10679 return (PARSER_OK
);
10682 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10684 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10686 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10690 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10693 u32
*digest
= (u32
*) hash_buf
->digest
;
10695 salt_t
*salt
= hash_buf
->salt
;
10697 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10698 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10699 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10700 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10702 digest
[0] = byte_swap_32 (digest
[0]);
10703 digest
[1] = byte_swap_32 (digest
[1]);
10704 digest
[2] = byte_swap_32 (digest
[2]);
10705 digest
[3] = byte_swap_32 (digest
[3]);
10707 digest
[0] -= MD4M_A
;
10708 digest
[1] -= MD4M_B
;
10709 digest
[2] -= MD4M_C
;
10710 digest
[3] -= MD4M_D
;
10712 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10714 uint salt_len
= input_len
- 32 - 1;
10716 char *salt_buf
= input_buf
+ 32 + 1;
10718 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10720 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10722 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10724 salt
->salt_len
= salt_len
;
10726 return (PARSER_OK
);
10729 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10731 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10733 u32
*digest
= (u32
*) hash_buf
->digest
;
10735 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10736 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10737 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10738 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10740 digest
[0] = byte_swap_32 (digest
[0]);
10741 digest
[1] = byte_swap_32 (digest
[1]);
10742 digest
[2] = byte_swap_32 (digest
[2]);
10743 digest
[3] = byte_swap_32 (digest
[3]);
10745 digest
[0] -= MD5M_A
;
10746 digest
[1] -= MD5M_B
;
10747 digest
[2] -= MD5M_C
;
10748 digest
[3] -= MD5M_D
;
10750 return (PARSER_OK
);
10753 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10755 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10757 u32
*digest
= (u32
*) hash_buf
->digest
;
10759 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10760 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10764 digest
[0] = byte_swap_32 (digest
[0]);
10765 digest
[1] = byte_swap_32 (digest
[1]);
10767 return (PARSER_OK
);
10770 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10772 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10774 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10778 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10781 u32
*digest
= (u32
*) hash_buf
->digest
;
10783 salt_t
*salt
= hash_buf
->salt
;
10785 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10786 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10787 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10788 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10790 digest
[0] = byte_swap_32 (digest
[0]);
10791 digest
[1] = byte_swap_32 (digest
[1]);
10792 digest
[2] = byte_swap_32 (digest
[2]);
10793 digest
[3] = byte_swap_32 (digest
[3]);
10795 digest
[0] -= MD5M_A
;
10796 digest
[1] -= MD5M_B
;
10797 digest
[2] -= MD5M_C
;
10798 digest
[3] -= MD5M_D
;
10800 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10802 uint salt_len
= input_len
- 32 - 1;
10804 char *salt_buf
= input_buf
+ 32 + 1;
10806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10808 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10812 salt
->salt_len
= salt_len
;
10814 return (PARSER_OK
);
10817 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10819 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10821 u32
*digest
= (u32
*) hash_buf
->digest
;
10823 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10824 | itoa64_to_int (input_buf
[ 1]) << 6
10825 | itoa64_to_int (input_buf
[ 2]) << 12
10826 | itoa64_to_int (input_buf
[ 3]) << 18;
10827 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10828 | itoa64_to_int (input_buf
[ 5]) << 6
10829 | itoa64_to_int (input_buf
[ 6]) << 12
10830 | itoa64_to_int (input_buf
[ 7]) << 18;
10831 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10832 | itoa64_to_int (input_buf
[ 9]) << 6
10833 | itoa64_to_int (input_buf
[10]) << 12
10834 | itoa64_to_int (input_buf
[11]) << 18;
10835 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10836 | itoa64_to_int (input_buf
[13]) << 6
10837 | itoa64_to_int (input_buf
[14]) << 12
10838 | itoa64_to_int (input_buf
[15]) << 18;
10840 digest
[0] -= MD5M_A
;
10841 digest
[1] -= MD5M_B
;
10842 digest
[2] -= MD5M_C
;
10843 digest
[3] -= MD5M_D
;
10845 digest
[0] &= 0x00ffffff;
10846 digest
[1] &= 0x00ffffff;
10847 digest
[2] &= 0x00ffffff;
10848 digest
[3] &= 0x00ffffff;
10850 return (PARSER_OK
);
10853 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10855 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10857 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10861 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10864 u32
*digest
= (u32
*) hash_buf
->digest
;
10866 salt_t
*salt
= hash_buf
->salt
;
10868 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10869 | itoa64_to_int (input_buf
[ 1]) << 6
10870 | itoa64_to_int (input_buf
[ 2]) << 12
10871 | itoa64_to_int (input_buf
[ 3]) << 18;
10872 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10873 | itoa64_to_int (input_buf
[ 5]) << 6
10874 | itoa64_to_int (input_buf
[ 6]) << 12
10875 | itoa64_to_int (input_buf
[ 7]) << 18;
10876 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10877 | itoa64_to_int (input_buf
[ 9]) << 6
10878 | itoa64_to_int (input_buf
[10]) << 12
10879 | itoa64_to_int (input_buf
[11]) << 18;
10880 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10881 | itoa64_to_int (input_buf
[13]) << 6
10882 | itoa64_to_int (input_buf
[14]) << 12
10883 | itoa64_to_int (input_buf
[15]) << 18;
10885 digest
[0] -= MD5M_A
;
10886 digest
[1] -= MD5M_B
;
10887 digest
[2] -= MD5M_C
;
10888 digest
[3] -= MD5M_D
;
10890 digest
[0] &= 0x00ffffff;
10891 digest
[1] &= 0x00ffffff;
10892 digest
[2] &= 0x00ffffff;
10893 digest
[3] &= 0x00ffffff;
10895 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10897 uint salt_len
= input_len
- 16 - 1;
10899 char *salt_buf
= input_buf
+ 16 + 1;
10901 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10903 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10905 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10907 salt
->salt_len
= salt_len
;
10909 return (PARSER_OK
);
10912 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10914 key
[0] = (nthash
[0] >> 0);
10915 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10916 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10917 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10918 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10919 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10920 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10921 key
[7] = (nthash
[6] << 1);
10933 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10935 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10937 u32
*digest
= (u32
*) hash_buf
->digest
;
10939 salt_t
*salt
= hash_buf
->salt
;
10941 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10947 char *user_pos
= input_buf
;
10949 char *unused_pos
= strchr (user_pos
, ':');
10951 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10953 uint user_len
= unused_pos
- user_pos
;
10955 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10959 char *domain_pos
= strchr (unused_pos
, ':');
10961 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10963 uint unused_len
= domain_pos
- unused_pos
;
10965 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10969 char *srvchall_pos
= strchr (domain_pos
, ':');
10971 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10973 uint domain_len
= srvchall_pos
- domain_pos
;
10975 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10979 char *hash_pos
= strchr (srvchall_pos
, ':');
10981 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10983 uint srvchall_len
= hash_pos
- srvchall_pos
;
10985 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10989 char *clichall_pos
= strchr (hash_pos
, ':');
10991 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10993 uint hash_len
= clichall_pos
- hash_pos
;
10995 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10999 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11001 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11004 * store some data for later use
11007 netntlm
->user_len
= user_len
* 2;
11008 netntlm
->domain_len
= domain_len
* 2;
11009 netntlm
->srvchall_len
= srvchall_len
/ 2;
11010 netntlm
->clichall_len
= clichall_len
/ 2;
11012 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11013 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11016 * handle username and domainname
11019 for (uint i
= 0; i
< user_len
; i
++)
11021 *userdomain_ptr
++ = user_pos
[i
];
11022 *userdomain_ptr
++ = 0;
11025 for (uint i
= 0; i
< domain_len
; i
++)
11027 *userdomain_ptr
++ = domain_pos
[i
];
11028 *userdomain_ptr
++ = 0;
11032 * handle server challenge encoding
11035 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11037 const char p0
= srvchall_pos
[i
+ 0];
11038 const char p1
= srvchall_pos
[i
+ 1];
11040 *chall_ptr
++ = hex_convert (p1
) << 0
11041 | hex_convert (p0
) << 4;
11045 * handle client challenge encoding
11048 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11050 const char p0
= clichall_pos
[i
+ 0];
11051 const char p1
= clichall_pos
[i
+ 1];
11053 *chall_ptr
++ = hex_convert (p1
) << 0
11054 | hex_convert (p0
) << 4;
11061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11063 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11065 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11067 salt
->salt_len
= salt_len
;
11069 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11070 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11071 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11072 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11074 digest
[0] = byte_swap_32 (digest
[0]);
11075 digest
[1] = byte_swap_32 (digest
[1]);
11076 digest
[2] = byte_swap_32 (digest
[2]);
11077 digest
[3] = byte_swap_32 (digest
[3]);
11079 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11081 uint digest_tmp
[2] = { 0 };
11083 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11084 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11086 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11087 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11089 /* special case 2: ESS */
11091 if (srvchall_len
== 48)
11093 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11095 uint w
[16] = { 0 };
11097 w
[ 0] = netntlm
->chall_buf
[6];
11098 w
[ 1] = netntlm
->chall_buf
[7];
11099 w
[ 2] = netntlm
->chall_buf
[0];
11100 w
[ 3] = netntlm
->chall_buf
[1];
11104 uint dgst
[4] = { 0 };
11113 salt
->salt_buf
[0] = dgst
[0];
11114 salt
->salt_buf
[1] = dgst
[1];
11118 /* precompute netntlmv1 exploit start */
11120 for (uint i
= 0; i
< 0x10000; i
++)
11122 uint key_md4
[2] = { i
, 0 };
11123 uint key_des
[2] = { 0, 0 };
11125 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11127 uint Kc
[16] = { 0 };
11128 uint Kd
[16] = { 0 };
11130 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11132 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11134 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11136 if (data3
[0] != digest_tmp
[0]) continue;
11137 if (data3
[1] != digest_tmp
[1]) continue;
11139 salt
->salt_buf
[2] = i
;
11141 salt
->salt_len
= 24;
11146 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11147 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11149 /* precompute netntlmv1 exploit stop */
11153 IP (digest
[0], digest
[1], tt
);
11154 IP (digest
[2], digest
[3], tt
);
11156 digest
[0] = rotr32 (digest
[0], 29);
11157 digest
[1] = rotr32 (digest
[1], 29);
11158 digest
[2] = rotr32 (digest
[2], 29);
11159 digest
[3] = rotr32 (digest
[3], 29);
11161 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11163 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11164 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11166 return (PARSER_OK
);
11169 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11171 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11173 u32
*digest
= (u32
*) hash_buf
->digest
;
11175 salt_t
*salt
= hash_buf
->salt
;
11177 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11183 char *user_pos
= input_buf
;
11185 char *unused_pos
= strchr (user_pos
, ':');
11187 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11189 uint user_len
= unused_pos
- user_pos
;
11191 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11195 char *domain_pos
= strchr (unused_pos
, ':');
11197 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11199 uint unused_len
= domain_pos
- unused_pos
;
11201 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11205 char *srvchall_pos
= strchr (domain_pos
, ':');
11207 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11209 uint domain_len
= srvchall_pos
- domain_pos
;
11211 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11215 char *hash_pos
= strchr (srvchall_pos
, ':');
11217 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11219 uint srvchall_len
= hash_pos
- srvchall_pos
;
11221 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11225 char *clichall_pos
= strchr (hash_pos
, ':');
11227 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11229 uint hash_len
= clichall_pos
- hash_pos
;
11231 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11235 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11237 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11239 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11242 * store some data for later use
11245 netntlm
->user_len
= user_len
* 2;
11246 netntlm
->domain_len
= domain_len
* 2;
11247 netntlm
->srvchall_len
= srvchall_len
/ 2;
11248 netntlm
->clichall_len
= clichall_len
/ 2;
11250 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11251 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11254 * handle username and domainname
11257 for (uint i
= 0; i
< user_len
; i
++)
11259 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11260 *userdomain_ptr
++ = 0;
11263 for (uint i
= 0; i
< domain_len
; i
++)
11265 *userdomain_ptr
++ = domain_pos
[i
];
11266 *userdomain_ptr
++ = 0;
11269 *userdomain_ptr
++ = 0x80;
11272 * handle server challenge encoding
11275 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11277 const char p0
= srvchall_pos
[i
+ 0];
11278 const char p1
= srvchall_pos
[i
+ 1];
11280 *chall_ptr
++ = hex_convert (p1
) << 0
11281 | hex_convert (p0
) << 4;
11285 * handle client challenge encoding
11288 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11290 const char p0
= clichall_pos
[i
+ 0];
11291 const char p1
= clichall_pos
[i
+ 1];
11293 *chall_ptr
++ = hex_convert (p1
) << 0
11294 | hex_convert (p0
) << 4;
11297 *chall_ptr
++ = 0x80;
11300 * handle hash itself
11303 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11304 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11305 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11306 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11308 digest
[0] = byte_swap_32 (digest
[0]);
11309 digest
[1] = byte_swap_32 (digest
[1]);
11310 digest
[2] = byte_swap_32 (digest
[2]);
11311 digest
[3] = byte_swap_32 (digest
[3]);
11314 * reuse challange data as salt_buf, its the buffer that is most likely unique
11317 salt
->salt_buf
[0] = 0;
11318 salt
->salt_buf
[1] = 0;
11319 salt
->salt_buf
[2] = 0;
11320 salt
->salt_buf
[3] = 0;
11321 salt
->salt_buf
[4] = 0;
11322 salt
->salt_buf
[5] = 0;
11323 salt
->salt_buf
[6] = 0;
11324 salt
->salt_buf
[7] = 0;
11328 uptr
= (uint
*) netntlm
->userdomain_buf
;
11330 for (uint i
= 0; i
< 16; i
+= 16)
11332 md5_64 (uptr
, salt
->salt_buf
);
11335 uptr
= (uint
*) netntlm
->chall_buf
;
11337 for (uint i
= 0; i
< 256; i
+= 16)
11339 md5_64 (uptr
, salt
->salt_buf
);
11342 salt
->salt_len
= 16;
11344 return (PARSER_OK
);
11347 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11349 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11351 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11355 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11358 u32
*digest
= (u32
*) hash_buf
->digest
;
11360 salt_t
*salt
= hash_buf
->salt
;
11362 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11363 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11364 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11365 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11367 digest
[0] = byte_swap_32 (digest
[0]);
11368 digest
[1] = byte_swap_32 (digest
[1]);
11369 digest
[2] = byte_swap_32 (digest
[2]);
11370 digest
[3] = byte_swap_32 (digest
[3]);
11372 digest
[0] -= MD5M_A
;
11373 digest
[1] -= MD5M_B
;
11374 digest
[2] -= MD5M_C
;
11375 digest
[3] -= MD5M_D
;
11377 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11379 uint salt_len
= input_len
- 32 - 1;
11381 char *salt_buf
= input_buf
+ 32 + 1;
11383 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11385 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11387 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11389 salt
->salt_len
= salt_len
;
11391 return (PARSER_OK
);
11394 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11396 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11398 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11402 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11405 u32
*digest
= (u32
*) hash_buf
->digest
;
11407 salt_t
*salt
= hash_buf
->salt
;
11409 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11410 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11411 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11412 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11414 digest
[0] = byte_swap_32 (digest
[0]);
11415 digest
[1] = byte_swap_32 (digest
[1]);
11416 digest
[2] = byte_swap_32 (digest
[2]);
11417 digest
[3] = byte_swap_32 (digest
[3]);
11419 digest
[0] -= MD5M_A
;
11420 digest
[1] -= MD5M_B
;
11421 digest
[2] -= MD5M_C
;
11422 digest
[3] -= MD5M_D
;
11424 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11426 uint salt_len
= input_len
- 32 - 1;
11428 char *salt_buf
= input_buf
+ 32 + 1;
11430 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11432 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11434 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11436 salt
->salt_len
= salt_len
;
11438 return (PARSER_OK
);
11441 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11443 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11445 u32
*digest
= (u32
*) hash_buf
->digest
;
11447 salt_t
*salt
= hash_buf
->salt
;
11449 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11450 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11451 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11452 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11454 digest
[0] = byte_swap_32 (digest
[0]);
11455 digest
[1] = byte_swap_32 (digest
[1]);
11456 digest
[2] = byte_swap_32 (digest
[2]);
11457 digest
[3] = byte_swap_32 (digest
[3]);
11459 digest
[0] -= MD5M_A
;
11460 digest
[1] -= MD5M_B
;
11461 digest
[2] -= MD5M_C
;
11462 digest
[3] -= MD5M_D
;
11465 * This is a virtual salt. While the algorithm is basically not salted
11466 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11467 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11470 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11472 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11474 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11476 salt
->salt_len
= salt_len
;
11478 return (PARSER_OK
);
11481 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11483 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11485 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11489 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11492 u32
*digest
= (u32
*) hash_buf
->digest
;
11494 salt_t
*salt
= hash_buf
->salt
;
11496 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11497 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11498 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11499 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11501 digest
[0] = byte_swap_32 (digest
[0]);
11502 digest
[1] = byte_swap_32 (digest
[1]);
11503 digest
[2] = byte_swap_32 (digest
[2]);
11504 digest
[3] = byte_swap_32 (digest
[3]);
11506 digest
[0] -= MD5M_A
;
11507 digest
[1] -= MD5M_B
;
11508 digest
[2] -= MD5M_C
;
11509 digest
[3] -= MD5M_D
;
11511 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11513 uint salt_len
= input_len
- 32 - 1;
11515 char *salt_buf
= input_buf
+ 32 + 1;
11517 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11519 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11521 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11523 salt
->salt_len
= salt_len
;
11525 return (PARSER_OK
);
11528 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11530 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11532 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11536 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11539 u32
*digest
= (u32
*) hash_buf
->digest
;
11541 salt_t
*salt
= hash_buf
->salt
;
11543 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11544 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11545 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11546 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11548 digest
[0] = byte_swap_32 (digest
[0]);
11549 digest
[1] = byte_swap_32 (digest
[1]);
11550 digest
[2] = byte_swap_32 (digest
[2]);
11551 digest
[3] = byte_swap_32 (digest
[3]);
11553 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11555 uint salt_len
= input_len
- 32 - 1;
11557 char *salt_buf
= input_buf
+ 32 + 1;
11559 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11561 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11563 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11565 salt
->salt_len
= salt_len
;
11567 return (PARSER_OK
);
11570 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11572 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11574 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11578 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11581 u32
*digest
= (u32
*) hash_buf
->digest
;
11583 salt_t
*salt
= hash_buf
->salt
;
11585 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11586 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11587 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11588 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11590 digest
[0] = byte_swap_32 (digest
[0]);
11591 digest
[1] = byte_swap_32 (digest
[1]);
11592 digest
[2] = byte_swap_32 (digest
[2]);
11593 digest
[3] = byte_swap_32 (digest
[3]);
11595 digest
[0] -= MD4M_A
;
11596 digest
[1] -= MD4M_B
;
11597 digest
[2] -= MD4M_C
;
11598 digest
[3] -= MD4M_D
;
11600 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11602 uint salt_len
= input_len
- 32 - 1;
11604 char *salt_buf
= input_buf
+ 32 + 1;
11606 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11608 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11610 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11612 salt
->salt_len
= salt_len
;
11614 return (PARSER_OK
);
11617 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11619 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11621 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11625 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11628 u32
*digest
= (u32
*) hash_buf
->digest
;
11630 salt_t
*salt
= hash_buf
->salt
;
11632 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11633 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11634 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11635 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11637 digest
[0] = byte_swap_32 (digest
[0]);
11638 digest
[1] = byte_swap_32 (digest
[1]);
11639 digest
[2] = byte_swap_32 (digest
[2]);
11640 digest
[3] = byte_swap_32 (digest
[3]);
11642 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11644 uint salt_len
= input_len
- 32 - 1;
11646 char *salt_buf
= input_buf
+ 32 + 1;
11648 uint salt_pc_block
[16] = { 0 };
11650 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11652 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11654 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11656 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11658 salt_pc_block
[14] = salt_len
* 8;
11660 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11662 md5_64 (salt_pc_block
, salt_pc_digest
);
11664 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11665 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11666 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11667 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11669 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11671 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11673 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11675 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11676 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11677 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11678 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11680 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11682 return (PARSER_OK
);
11685 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11687 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11689 u32
*digest
= (u32
*) hash_buf
->digest
;
11691 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11692 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11693 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11694 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11695 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11697 digest
[0] -= SHA1M_A
;
11698 digest
[1] -= SHA1M_B
;
11699 digest
[2] -= SHA1M_C
;
11700 digest
[3] -= SHA1M_D
;
11701 digest
[4] -= SHA1M_E
;
11703 return (PARSER_OK
);
11706 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11708 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11710 u32
*digest
= (u32
*) hash_buf
->digest
;
11712 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11713 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11714 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11715 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11716 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11718 return (PARSER_OK
);
11721 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11723 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11725 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11727 u32
*digest
= (u32
*) hash_buf
->digest
;
11731 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11732 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11733 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11734 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11735 digest
[4] = 0x00000000;
11737 return (PARSER_OK
);
11740 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11742 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11744 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11748 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11751 u32
*digest
= (u32
*) hash_buf
->digest
;
11753 salt_t
*salt
= hash_buf
->salt
;
11755 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11756 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11757 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11758 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11759 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11761 digest
[0] -= SHA1M_A
;
11762 digest
[1] -= SHA1M_B
;
11763 digest
[2] -= SHA1M_C
;
11764 digest
[3] -= SHA1M_D
;
11765 digest
[4] -= SHA1M_E
;
11767 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11769 uint salt_len
= input_len
- 40 - 1;
11771 char *salt_buf
= input_buf
+ 40 + 1;
11773 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11775 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11777 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11779 salt
->salt_len
= salt_len
;
11781 return (PARSER_OK
);
11784 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11786 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11788 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11792 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11795 u32
*digest
= (u32
*) hash_buf
->digest
;
11796 salt_t
*salt
= hash_buf
->salt
;
11797 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11798 u8 pstoken_tmp
[DISPLAY_LEN_MAX_13500
- 40 - 1];
11800 memset(pstoken_tmp
, 0, DISPLAY_LEN_MAX_13500
- 40 - 1);
11802 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11803 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11804 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11805 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11806 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11808 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11810 uint salt_len
= input_len
- 40 - 1;
11812 char *salt_buf
= input_buf
+ 40 + 1;
11814 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11816 for (uint i
= 0; i
< salt_len
/ 2; i
++)
11818 pstoken_tmp
[i
] = hex_to_u8 ((const u8
*) &salt_buf
[i
* 2]);
11822 salt
->salt_len
= salt_len
;
11823 pstoken
->salt_len
= salt_len
;
11825 memcpy(salt
->salt_buf
, pstoken_tmp
, 16);
11826 memcpy(pstoken
->salt_buf
, pstoken_tmp
, salt_len
);
11828 return (PARSER_OK
);
11832 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11834 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11836 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11838 u32
*digest
= (u32
*) hash_buf
->digest
;
11840 u8 tmp_buf
[100] = { 0 };
11842 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11844 memcpy (digest
, tmp_buf
, 20);
11846 digest
[0] = byte_swap_32 (digest
[0]);
11847 digest
[1] = byte_swap_32 (digest
[1]);
11848 digest
[2] = byte_swap_32 (digest
[2]);
11849 digest
[3] = byte_swap_32 (digest
[3]);
11850 digest
[4] = byte_swap_32 (digest
[4]);
11852 digest
[0] -= SHA1M_A
;
11853 digest
[1] -= SHA1M_B
;
11854 digest
[2] -= SHA1M_C
;
11855 digest
[3] -= SHA1M_D
;
11856 digest
[4] -= SHA1M_E
;
11858 return (PARSER_OK
);
11861 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11863 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11865 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11867 u32
*digest
= (u32
*) hash_buf
->digest
;
11869 salt_t
*salt
= hash_buf
->salt
;
11871 u8 tmp_buf
[100] = { 0 };
11873 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11875 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11877 memcpy (digest
, tmp_buf
, 20);
11879 int salt_len
= tmp_len
- 20;
11881 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11883 salt
->salt_len
= salt_len
;
11885 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11887 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11889 char *ptr
= (char *) salt
->salt_buf
;
11891 ptr
[salt
->salt_len
] = 0x80;
11894 digest
[0] = byte_swap_32 (digest
[0]);
11895 digest
[1] = byte_swap_32 (digest
[1]);
11896 digest
[2] = byte_swap_32 (digest
[2]);
11897 digest
[3] = byte_swap_32 (digest
[3]);
11898 digest
[4] = byte_swap_32 (digest
[4]);
11900 digest
[0] -= SHA1M_A
;
11901 digest
[1] -= SHA1M_B
;
11902 digest
[2] -= SHA1M_C
;
11903 digest
[3] -= SHA1M_D
;
11904 digest
[4] -= SHA1M_E
;
11906 return (PARSER_OK
);
11909 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11911 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11913 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11915 u32
*digest
= (u32
*) hash_buf
->digest
;
11917 salt_t
*salt
= hash_buf
->salt
;
11919 char *salt_buf
= input_buf
+ 6;
11923 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11925 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11927 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11929 salt
->salt_len
= salt_len
;
11931 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11933 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11934 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11935 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11936 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11937 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11939 digest
[0] -= SHA1M_A
;
11940 digest
[1] -= SHA1M_B
;
11941 digest
[2] -= SHA1M_C
;
11942 digest
[3] -= SHA1M_D
;
11943 digest
[4] -= SHA1M_E
;
11945 return (PARSER_OK
);
11948 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11950 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11952 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11954 u32
*digest
= (u32
*) hash_buf
->digest
;
11956 salt_t
*salt
= hash_buf
->salt
;
11958 char *salt_buf
= input_buf
+ 6;
11962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11968 salt
->salt_len
= salt_len
;
11970 char *hash_pos
= input_buf
+ 6 + 8;
11972 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11973 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11974 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11975 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11976 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11978 digest
[0] -= SHA1M_A
;
11979 digest
[1] -= SHA1M_B
;
11980 digest
[2] -= SHA1M_C
;
11981 digest
[3] -= SHA1M_D
;
11982 digest
[4] -= SHA1M_E
;
11984 return (PARSER_OK
);
11987 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11989 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11991 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11993 u64
*digest
= (u64
*) hash_buf
->digest
;
11995 salt_t
*salt
= hash_buf
->salt
;
11997 char *salt_buf
= input_buf
+ 6;
12001 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12003 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12005 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12007 salt
->salt_len
= salt_len
;
12009 char *hash_pos
= input_buf
+ 6 + 8;
12011 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12012 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12013 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12014 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12015 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12016 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12017 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12018 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12020 digest
[0] -= SHA512M_A
;
12021 digest
[1] -= SHA512M_B
;
12022 digest
[2] -= SHA512M_C
;
12023 digest
[3] -= SHA512M_D
;
12024 digest
[4] -= SHA512M_E
;
12025 digest
[5] -= SHA512M_F
;
12026 digest
[6] -= SHA512M_G
;
12027 digest
[7] -= SHA512M_H
;
12029 return (PARSER_OK
);
12032 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12034 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12036 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12040 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12043 u32
*digest
= (u32
*) hash_buf
->digest
;
12045 salt_t
*salt
= hash_buf
->salt
;
12047 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12048 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12052 digest
[0] = byte_swap_32 (digest
[0]);
12053 digest
[1] = byte_swap_32 (digest
[1]);
12055 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12057 uint salt_len
= input_len
- 16 - 1;
12059 char *salt_buf
= input_buf
+ 16 + 1;
12061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12063 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12065 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12067 salt
->salt_len
= salt_len
;
12069 return (PARSER_OK
);
12072 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12074 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12076 u32
*digest
= (u32
*) hash_buf
->digest
;
12078 salt_t
*salt
= hash_buf
->salt
;
12080 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12081 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12082 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12083 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12084 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12086 digest
[0] -= SHA1M_A
;
12087 digest
[1] -= SHA1M_B
;
12088 digest
[2] -= SHA1M_C
;
12089 digest
[3] -= SHA1M_D
;
12090 digest
[4] -= SHA1M_E
;
12092 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12094 uint salt_len
= input_len
- 40 - 1;
12096 char *salt_buf
= input_buf
+ 40 + 1;
12098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12104 salt
->salt_len
= salt_len
;
12106 return (PARSER_OK
);
12109 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12111 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12113 u32
*digest
= (u32
*) hash_buf
->digest
;
12115 salt_t
*salt
= hash_buf
->salt
;
12117 char *hash_pos
= input_buf
;
12119 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12120 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12121 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12122 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12123 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12124 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12125 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12126 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12127 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12128 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12129 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12130 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12131 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12132 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12133 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12134 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12136 char *salt_pos
= input_buf
+ 128;
12138 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12139 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12140 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12141 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12143 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12144 salt
->salt_len
= 16;
12146 return (PARSER_OK
);
12149 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12151 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12153 u32
*digest
= (u32
*) hash_buf
->digest
;
12155 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12156 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12157 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12158 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12159 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12160 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12161 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12162 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12164 digest
[0] -= SHA256M_A
;
12165 digest
[1] -= SHA256M_B
;
12166 digest
[2] -= SHA256M_C
;
12167 digest
[3] -= SHA256M_D
;
12168 digest
[4] -= SHA256M_E
;
12169 digest
[5] -= SHA256M_F
;
12170 digest
[6] -= SHA256M_G
;
12171 digest
[7] -= SHA256M_H
;
12173 return (PARSER_OK
);
12176 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12178 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12180 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12184 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12187 u32
*digest
= (u32
*) hash_buf
->digest
;
12189 salt_t
*salt
= hash_buf
->salt
;
12191 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12192 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12193 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12194 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12195 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12196 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12197 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12198 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12200 digest
[0] -= SHA256M_A
;
12201 digest
[1] -= SHA256M_B
;
12202 digest
[2] -= SHA256M_C
;
12203 digest
[3] -= SHA256M_D
;
12204 digest
[4] -= SHA256M_E
;
12205 digest
[5] -= SHA256M_F
;
12206 digest
[6] -= SHA256M_G
;
12207 digest
[7] -= SHA256M_H
;
12209 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12211 uint salt_len
= input_len
- 64 - 1;
12213 char *salt_buf
= input_buf
+ 64 + 1;
12215 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12217 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12219 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12221 salt
->salt_len
= salt_len
;
12223 return (PARSER_OK
);
12226 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12228 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12230 u64
*digest
= (u64
*) hash_buf
->digest
;
12232 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12233 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12234 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12235 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12236 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12237 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12241 digest
[0] -= SHA384M_A
;
12242 digest
[1] -= SHA384M_B
;
12243 digest
[2] -= SHA384M_C
;
12244 digest
[3] -= SHA384M_D
;
12245 digest
[4] -= SHA384M_E
;
12246 digest
[5] -= SHA384M_F
;
12250 return (PARSER_OK
);
12253 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12255 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12257 u64
*digest
= (u64
*) hash_buf
->digest
;
12259 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12260 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12261 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12262 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12263 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12264 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12265 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12266 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12268 digest
[0] -= SHA512M_A
;
12269 digest
[1] -= SHA512M_B
;
12270 digest
[2] -= SHA512M_C
;
12271 digest
[3] -= SHA512M_D
;
12272 digest
[4] -= SHA512M_E
;
12273 digest
[5] -= SHA512M_F
;
12274 digest
[6] -= SHA512M_G
;
12275 digest
[7] -= SHA512M_H
;
12277 return (PARSER_OK
);
12280 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12282 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12284 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12288 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12291 u64
*digest
= (u64
*) hash_buf
->digest
;
12293 salt_t
*salt
= hash_buf
->salt
;
12295 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12296 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12297 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12298 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12299 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12300 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12301 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12302 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12304 digest
[0] -= SHA512M_A
;
12305 digest
[1] -= SHA512M_B
;
12306 digest
[2] -= SHA512M_C
;
12307 digest
[3] -= SHA512M_D
;
12308 digest
[4] -= SHA512M_E
;
12309 digest
[5] -= SHA512M_F
;
12310 digest
[6] -= SHA512M_G
;
12311 digest
[7] -= SHA512M_H
;
12313 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12315 uint salt_len
= input_len
- 128 - 1;
12317 char *salt_buf
= input_buf
+ 128 + 1;
12319 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12321 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12323 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12325 salt
->salt_len
= salt_len
;
12327 return (PARSER_OK
);
12330 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12332 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12334 u64
*digest
= (u64
*) hash_buf
->digest
;
12336 salt_t
*salt
= hash_buf
->salt
;
12338 char *salt_pos
= input_buf
+ 3;
12340 uint iterations_len
= 0;
12342 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12346 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12348 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12349 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12353 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12357 iterations_len
+= 8;
12361 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12364 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12366 char *hash_pos
= strchr (salt_pos
, '$');
12368 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12370 uint salt_len
= hash_pos
- salt_pos
;
12372 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12374 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12376 salt
->salt_len
= salt_len
;
12380 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12382 return (PARSER_OK
);
12385 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12387 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12389 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12391 u64
*digest
= (u64
*) hash_buf
->digest
;
12393 salt_t
*salt
= hash_buf
->salt
;
12395 uint keccak_mdlen
= input_len
/ 2;
12397 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12399 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12401 digest
[i
] = byte_swap_64 (digest
[i
]);
12404 salt
->keccak_mdlen
= keccak_mdlen
;
12406 return (PARSER_OK
);
12409 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12411 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12413 u32
*digest
= (u32
*) hash_buf
->digest
;
12415 salt_t
*salt
= hash_buf
->salt
;
12417 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12420 * Parse that strange long line
12425 size_t in_len
[9] = { 0 };
12427 in_off
[0] = strtok (input_buf
, ":");
12429 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12431 in_len
[0] = strlen (in_off
[0]);
12435 for (i
= 1; i
< 9; i
++)
12437 in_off
[i
] = strtok (NULL
, ":");
12439 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12441 in_len
[i
] = strlen (in_off
[i
]);
12444 char *ptr
= (char *) ikepsk
->msg_buf
;
12446 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12447 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12448 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12449 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12450 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12451 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12455 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12457 ptr
= (char *) ikepsk
->nr_buf
;
12459 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12460 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12464 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12467 * Store to database
12472 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12473 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12474 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12475 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12477 digest
[0] = byte_swap_32 (digest
[0]);
12478 digest
[1] = byte_swap_32 (digest
[1]);
12479 digest
[2] = byte_swap_32 (digest
[2]);
12480 digest
[3] = byte_swap_32 (digest
[3]);
12482 salt
->salt_len
= 32;
12484 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12485 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12486 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12487 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12488 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12489 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12490 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12491 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12493 return (PARSER_OK
);
12496 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12498 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12500 u32
*digest
= (u32
*) hash_buf
->digest
;
12502 salt_t
*salt
= hash_buf
->salt
;
12504 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12507 * Parse that strange long line
12512 size_t in_len
[9] = { 0 };
12514 in_off
[0] = strtok (input_buf
, ":");
12516 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12518 in_len
[0] = strlen (in_off
[0]);
12522 for (i
= 1; i
< 9; i
++)
12524 in_off
[i
] = strtok (NULL
, ":");
12526 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12528 in_len
[i
] = strlen (in_off
[i
]);
12531 char *ptr
= (char *) ikepsk
->msg_buf
;
12533 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12534 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12535 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12536 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12537 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12538 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12542 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12544 ptr
= (char *) ikepsk
->nr_buf
;
12546 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12547 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12551 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12554 * Store to database
12559 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12560 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12561 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12562 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12563 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12565 salt
->salt_len
= 32;
12567 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12568 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12569 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12570 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12571 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12572 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12573 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12574 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12576 return (PARSER_OK
);
12579 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12581 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12583 u32
*digest
= (u32
*) hash_buf
->digest
;
12585 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12586 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12587 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12588 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12589 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12591 digest
[0] = byte_swap_32 (digest
[0]);
12592 digest
[1] = byte_swap_32 (digest
[1]);
12593 digest
[2] = byte_swap_32 (digest
[2]);
12594 digest
[3] = byte_swap_32 (digest
[3]);
12595 digest
[4] = byte_swap_32 (digest
[4]);
12597 return (PARSER_OK
);
12600 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12602 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12604 u32
*digest
= (u32
*) hash_buf
->digest
;
12606 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12607 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12608 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12609 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12610 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12611 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12612 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12613 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12614 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12615 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12616 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12617 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12618 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12619 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12620 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12621 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12623 return (PARSER_OK
);
12626 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12628 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12630 u32
*digest
= (u32
*) hash_buf
->digest
;
12632 salt_t
*salt
= hash_buf
->salt
;
12634 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12635 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12636 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12637 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12638 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12640 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12642 uint salt_len
= input_len
- 40 - 1;
12644 char *salt_buf
= input_buf
+ 40 + 1;
12646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12652 salt
->salt_len
= salt_len
;
12654 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12656 return (PARSER_OK
);
12659 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12661 u32
*digest
= (u32
*) hash_buf
->digest
;
12663 salt_t
*salt
= hash_buf
->salt
;
12665 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12667 if (input_len
== 0)
12669 log_error ("TrueCrypt container not specified");
12674 FILE *fp
= fopen (input_buf
, "rb");
12678 log_error ("%s: %s", input_buf
, strerror (errno
));
12683 char buf
[512] = { 0 };
12685 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12689 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12691 memcpy (tc
->salt_buf
, buf
, 64);
12693 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12695 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12697 salt
->salt_len
= 4;
12699 salt
->salt_iter
= 1000 - 1;
12701 digest
[0] = tc
->data_buf
[0];
12703 return (PARSER_OK
);
12706 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12708 u32
*digest
= (u32
*) hash_buf
->digest
;
12710 salt_t
*salt
= hash_buf
->salt
;
12712 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12714 if (input_len
== 0)
12716 log_error ("TrueCrypt container not specified");
12721 FILE *fp
= fopen (input_buf
, "rb");
12725 log_error ("%s: %s", input_buf
, strerror (errno
));
12730 char buf
[512] = { 0 };
12732 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12736 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12738 memcpy (tc
->salt_buf
, buf
, 64);
12740 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12742 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12744 salt
->salt_len
= 4;
12746 salt
->salt_iter
= 2000 - 1;
12748 digest
[0] = tc
->data_buf
[0];
12750 return (PARSER_OK
);
12753 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12755 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12757 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12759 u32
*digest
= (u32
*) hash_buf
->digest
;
12761 salt_t
*salt
= hash_buf
->salt
;
12763 char *salt_pos
= input_buf
+ 6;
12765 char *hash_pos
= strchr (salt_pos
, '$');
12767 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12769 uint salt_len
= hash_pos
- salt_pos
;
12771 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12773 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12775 salt
->salt_len
= salt_len
;
12777 salt
->salt_iter
= 1000;
12781 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12783 return (PARSER_OK
);
12786 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12788 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12790 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12792 u32
*digest
= (u32
*) hash_buf
->digest
;
12794 salt_t
*salt
= hash_buf
->salt
;
12796 char *iter_pos
= input_buf
+ 7;
12798 char *salt_pos
= strchr (iter_pos
, '$');
12800 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12804 char *hash_pos
= strchr (salt_pos
, '$');
12806 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12808 uint salt_len
= hash_pos
- salt_pos
;
12810 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12812 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12814 salt
->salt_len
= salt_len
;
12816 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12818 salt
->salt_sign
[0] = atoi (salt_iter
);
12820 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12824 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12826 digest
[0] = byte_swap_32 (digest
[0]);
12827 digest
[1] = byte_swap_32 (digest
[1]);
12828 digest
[2] = byte_swap_32 (digest
[2]);
12829 digest
[3] = byte_swap_32 (digest
[3]);
12830 digest
[4] = byte_swap_32 (digest
[4]);
12832 return (PARSER_OK
);
12835 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12837 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12839 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12841 u32
*digest
= (u32
*) hash_buf
->digest
;
12843 salt_t
*salt
= hash_buf
->salt
;
12845 char *iter_pos
= input_buf
+ 9;
12847 char *salt_pos
= strchr (iter_pos
, '$');
12849 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12853 char *hash_pos
= strchr (salt_pos
, '$');
12855 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12857 uint salt_len
= hash_pos
- salt_pos
;
12859 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12861 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12863 salt
->salt_len
= salt_len
;
12865 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12867 salt
->salt_sign
[0] = atoi (salt_iter
);
12869 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12873 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12875 digest
[0] = byte_swap_32 (digest
[0]);
12876 digest
[1] = byte_swap_32 (digest
[1]);
12877 digest
[2] = byte_swap_32 (digest
[2]);
12878 digest
[3] = byte_swap_32 (digest
[3]);
12879 digest
[4] = byte_swap_32 (digest
[4]);
12880 digest
[5] = byte_swap_32 (digest
[5]);
12881 digest
[6] = byte_swap_32 (digest
[6]);
12882 digest
[7] = byte_swap_32 (digest
[7]);
12884 return (PARSER_OK
);
12887 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12889 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12891 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12893 u64
*digest
= (u64
*) hash_buf
->digest
;
12895 salt_t
*salt
= hash_buf
->salt
;
12897 char *iter_pos
= input_buf
+ 9;
12899 char *salt_pos
= strchr (iter_pos
, '$');
12901 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12905 char *hash_pos
= strchr (salt_pos
, '$');
12907 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12909 uint salt_len
= hash_pos
- salt_pos
;
12911 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12913 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12915 salt
->salt_len
= salt_len
;
12917 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12919 salt
->salt_sign
[0] = atoi (salt_iter
);
12921 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12925 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12927 digest
[0] = byte_swap_64 (digest
[0]);
12928 digest
[1] = byte_swap_64 (digest
[1]);
12929 digest
[2] = byte_swap_64 (digest
[2]);
12930 digest
[3] = byte_swap_64 (digest
[3]);
12931 digest
[4] = byte_swap_64 (digest
[4]);
12932 digest
[5] = byte_swap_64 (digest
[5]);
12933 digest
[6] = byte_swap_64 (digest
[6]);
12934 digest
[7] = byte_swap_64 (digest
[7]);
12936 return (PARSER_OK
);
12939 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12941 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12943 u32
*digest
= (u32
*) hash_buf
->digest
;
12945 salt_t
*salt
= hash_buf
->salt
;
12947 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12953 char *iterations_pos
= input_buf
;
12955 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12957 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12959 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12961 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12965 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12967 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12969 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12971 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12973 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12975 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12980 * pbkdf2 iterations
12983 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12986 * handle salt encoding
12989 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12991 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12993 const char p0
= saltbuf_pos
[i
+ 0];
12994 const char p1
= saltbuf_pos
[i
+ 1];
12996 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12997 | hex_convert (p0
) << 4;
13000 salt
->salt_len
= saltbuf_len
/ 2;
13003 * handle cipher encoding
13006 uint
*tmp
= (uint
*) mymalloc (32);
13008 char *cipherbuf_ptr
= (char *) tmp
;
13010 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13012 const char p0
= cipherbuf_pos
[i
+ 0];
13013 const char p1
= cipherbuf_pos
[i
+ 1];
13015 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13016 | hex_convert (p0
) << 4;
13019 // iv is stored at salt_buf 4 (length 16)
13020 // data is stored at salt_buf 8 (length 16)
13022 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13023 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13024 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13025 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13027 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13028 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13029 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13030 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13034 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13036 const char p0
= cipherbuf_pos
[j
+ 0];
13037 const char p1
= cipherbuf_pos
[j
+ 1];
13039 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13040 | hex_convert (p0
) << 4;
13047 digest
[0] = 0x10101010;
13048 digest
[1] = 0x10101010;
13049 digest
[2] = 0x10101010;
13050 digest
[3] = 0x10101010;
13052 return (PARSER_OK
);
13055 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13057 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13059 u32
*digest
= (u32
*) hash_buf
->digest
;
13061 salt_t
*salt
= hash_buf
->salt
;
13063 char *hashbuf_pos
= input_buf
;
13065 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13067 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13069 uint hash_len
= iterations_pos
- hashbuf_pos
;
13071 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13075 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13077 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13079 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13083 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13085 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13087 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13089 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13091 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13093 salt
->salt_len
= salt_len
;
13095 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13097 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13098 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13099 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13100 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13102 return (PARSER_OK
);
13105 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13107 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13109 u32
*digest
= (u32
*) hash_buf
->digest
;
13111 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13112 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13113 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13114 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13115 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13116 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13117 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13118 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13120 digest
[0] = byte_swap_32 (digest
[0]);
13121 digest
[1] = byte_swap_32 (digest
[1]);
13122 digest
[2] = byte_swap_32 (digest
[2]);
13123 digest
[3] = byte_swap_32 (digest
[3]);
13124 digest
[4] = byte_swap_32 (digest
[4]);
13125 digest
[5] = byte_swap_32 (digest
[5]);
13126 digest
[6] = byte_swap_32 (digest
[6]);
13127 digest
[7] = byte_swap_32 (digest
[7]);
13129 return (PARSER_OK
);
13132 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13134 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13136 u32
*digest
= (u32
*) hash_buf
->digest
;
13138 salt_t
*salt
= hash_buf
->salt
;
13140 char *salt_pos
= input_buf
+ 3;
13142 uint iterations_len
= 0;
13144 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13148 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13150 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13151 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13155 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13159 iterations_len
+= 8;
13163 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13166 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13168 char *hash_pos
= strchr (salt_pos
, '$');
13170 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13172 uint salt_len
= hash_pos
- salt_pos
;
13174 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13176 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13178 salt
->salt_len
= salt_len
;
13182 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13184 return (PARSER_OK
);
13187 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13189 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13191 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13193 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13195 u64
*digest
= (u64
*) hash_buf
->digest
;
13197 salt_t
*salt
= hash_buf
->salt
;
13199 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13201 char *iter_pos
= input_buf
+ 4;
13203 char *salt_pos
= strchr (iter_pos
, '$');
13205 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13209 char *hash_pos
= strchr (salt_pos
, '$');
13211 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13213 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13217 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13218 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13219 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13220 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13221 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13222 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13223 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13224 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13226 uint salt_len
= hash_pos
- salt_pos
- 1;
13228 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13230 salt
->salt_len
= salt_len
/ 2;
13232 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13233 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13234 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13235 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13236 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13237 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13238 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13239 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13241 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13242 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13243 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13244 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13245 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13246 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13247 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13248 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13249 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13250 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13252 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13254 salt
->salt_iter
= atoi (iter_pos
) - 1;
13256 return (PARSER_OK
);
13259 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13261 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13263 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13265 u32
*digest
= (u32
*) hash_buf
->digest
;
13267 salt_t
*salt
= hash_buf
->salt
;
13269 char *salt_pos
= input_buf
+ 14;
13271 char *hash_pos
= strchr (salt_pos
, '*');
13273 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13277 uint salt_len
= hash_pos
- salt_pos
- 1;
13279 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13281 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13283 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13285 salt
->salt_len
= salt_len
;
13287 u8 tmp_buf
[100] = { 0 };
13289 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13291 memcpy (digest
, tmp_buf
, 32);
13293 digest
[0] = byte_swap_32 (digest
[0]);
13294 digest
[1] = byte_swap_32 (digest
[1]);
13295 digest
[2] = byte_swap_32 (digest
[2]);
13296 digest
[3] = byte_swap_32 (digest
[3]);
13297 digest
[4] = byte_swap_32 (digest
[4]);
13298 digest
[5] = byte_swap_32 (digest
[5]);
13299 digest
[6] = byte_swap_32 (digest
[6]);
13300 digest
[7] = byte_swap_32 (digest
[7]);
13302 digest
[0] -= SHA256M_A
;
13303 digest
[1] -= SHA256M_B
;
13304 digest
[2] -= SHA256M_C
;
13305 digest
[3] -= SHA256M_D
;
13306 digest
[4] -= SHA256M_E
;
13307 digest
[5] -= SHA256M_F
;
13308 digest
[6] -= SHA256M_G
;
13309 digest
[7] -= SHA256M_H
;
13311 return (PARSER_OK
);
13314 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13316 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13318 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13320 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13322 u64
*digest
= (u64
*) hash_buf
->digest
;
13324 salt_t
*salt
= hash_buf
->salt
;
13326 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13328 char *iter_pos
= input_buf
+ 19;
13330 char *salt_pos
= strchr (iter_pos
, '.');
13332 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13336 char *hash_pos
= strchr (salt_pos
, '.');
13338 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13340 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13344 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13345 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13346 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13347 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13348 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13349 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13350 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13351 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13353 uint salt_len
= hash_pos
- salt_pos
- 1;
13357 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13361 for (i
= 0; i
< salt_len
; i
++)
13363 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13366 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13367 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13369 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13371 salt
->salt_len
= salt_len
;
13373 salt
->salt_iter
= atoi (iter_pos
) - 1;
13375 return (PARSER_OK
);
13378 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13380 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13382 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13384 u64
*digest
= (u64
*) hash_buf
->digest
;
13386 salt_t
*salt
= hash_buf
->salt
;
13388 u8 tmp_buf
[120] = { 0 };
13390 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13392 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13394 memcpy (digest
, tmp_buf
, 64);
13396 digest
[0] = byte_swap_64 (digest
[0]);
13397 digest
[1] = byte_swap_64 (digest
[1]);
13398 digest
[2] = byte_swap_64 (digest
[2]);
13399 digest
[3] = byte_swap_64 (digest
[3]);
13400 digest
[4] = byte_swap_64 (digest
[4]);
13401 digest
[5] = byte_swap_64 (digest
[5]);
13402 digest
[6] = byte_swap_64 (digest
[6]);
13403 digest
[7] = byte_swap_64 (digest
[7]);
13405 digest
[0] -= SHA512M_A
;
13406 digest
[1] -= SHA512M_B
;
13407 digest
[2] -= SHA512M_C
;
13408 digest
[3] -= SHA512M_D
;
13409 digest
[4] -= SHA512M_E
;
13410 digest
[5] -= SHA512M_F
;
13411 digest
[6] -= SHA512M_G
;
13412 digest
[7] -= SHA512M_H
;
13414 int salt_len
= tmp_len
- 64;
13416 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13418 salt
->salt_len
= salt_len
;
13420 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13422 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13424 char *ptr
= (char *) salt
->salt_buf
;
13426 ptr
[salt
->salt_len
] = 0x80;
13429 return (PARSER_OK
);
13432 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13434 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13436 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13440 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13443 u32
*digest
= (u32
*) hash_buf
->digest
;
13445 salt_t
*salt
= hash_buf
->salt
;
13447 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13448 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13449 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13450 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13452 digest
[0] = byte_swap_32 (digest
[0]);
13453 digest
[1] = byte_swap_32 (digest
[1]);
13454 digest
[2] = byte_swap_32 (digest
[2]);
13455 digest
[3] = byte_swap_32 (digest
[3]);
13457 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13459 uint salt_len
= input_len
- 32 - 1;
13461 char *salt_buf
= input_buf
+ 32 + 1;
13463 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13465 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13467 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13469 salt
->salt_len
= salt_len
;
13471 return (PARSER_OK
);
13474 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13476 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13478 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13482 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13485 u32
*digest
= (u32
*) hash_buf
->digest
;
13487 salt_t
*salt
= hash_buf
->salt
;
13489 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13490 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13491 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13492 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13493 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13495 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13497 uint salt_len
= input_len
- 40 - 1;
13499 char *salt_buf
= input_buf
+ 40 + 1;
13501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13503 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13505 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13507 salt
->salt_len
= salt_len
;
13509 return (PARSER_OK
);
13512 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13514 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13516 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13520 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13523 u32
*digest
= (u32
*) hash_buf
->digest
;
13525 salt_t
*salt
= hash_buf
->salt
;
13527 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13528 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13529 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13530 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13531 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13532 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13533 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13534 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13536 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13538 uint salt_len
= input_len
- 64 - 1;
13540 char *salt_buf
= input_buf
+ 64 + 1;
13542 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13544 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13546 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13548 salt
->salt_len
= salt_len
;
13550 return (PARSER_OK
);
13553 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13555 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13557 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13561 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13564 u64
*digest
= (u64
*) hash_buf
->digest
;
13566 salt_t
*salt
= hash_buf
->salt
;
13568 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13569 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13570 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13571 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13572 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13573 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13574 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13575 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13577 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13579 uint salt_len
= input_len
- 128 - 1;
13581 char *salt_buf
= input_buf
+ 128 + 1;
13583 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13585 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13587 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13589 salt
->salt_len
= salt_len
;
13591 return (PARSER_OK
);
13594 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13596 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13598 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13600 u32
*digest
= (u32
*) hash_buf
->digest
;
13602 salt_t
*salt
= hash_buf
->salt
;
13604 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13610 char *user_pos
= input_buf
+ 10 + 1;
13612 char *realm_pos
= strchr (user_pos
, '$');
13614 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13616 uint user_len
= realm_pos
- user_pos
;
13618 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13622 char *salt_pos
= strchr (realm_pos
, '$');
13624 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13626 uint realm_len
= salt_pos
- realm_pos
;
13628 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13632 char *data_pos
= strchr (salt_pos
, '$');
13634 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13636 uint salt_len
= data_pos
- salt_pos
;
13638 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13642 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13644 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13650 memcpy (krb5pa
->user
, user_pos
, user_len
);
13651 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13652 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13654 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13656 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13658 const char p0
= data_pos
[i
+ 0];
13659 const char p1
= data_pos
[i
+ 1];
13661 *timestamp_ptr
++ = hex_convert (p1
) << 0
13662 | hex_convert (p0
) << 4;
13665 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13667 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13669 const char p0
= data_pos
[i
+ 0];
13670 const char p1
= data_pos
[i
+ 1];
13672 *checksum_ptr
++ = hex_convert (p1
) << 0
13673 | hex_convert (p0
) << 4;
13677 * copy some data to generic buffers to make sorting happy
13680 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13681 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13682 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13683 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13684 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13685 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13686 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13687 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13688 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13690 salt
->salt_len
= 36;
13692 digest
[0] = krb5pa
->checksum
[0];
13693 digest
[1] = krb5pa
->checksum
[1];
13694 digest
[2] = krb5pa
->checksum
[2];
13695 digest
[3] = krb5pa
->checksum
[3];
13697 return (PARSER_OK
);
13700 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13702 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13704 u32
*digest
= (u32
*) hash_buf
->digest
;
13706 salt_t
*salt
= hash_buf
->salt
;
13712 char *salt_pos
= input_buf
;
13714 char *hash_pos
= strchr (salt_pos
, '$');
13716 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13718 uint salt_len
= hash_pos
- salt_pos
;
13720 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13724 uint hash_len
= input_len
- 1 - salt_len
;
13726 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13734 for (uint i
= 0; i
< salt_len
; i
++)
13736 if (salt_pos
[i
] == ' ') continue;
13741 // SAP user names cannot be longer than 12 characters
13742 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13744 // SAP user name cannot start with ! or ?
13745 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13751 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13753 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13755 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13757 salt
->salt_len
= salt_len
;
13759 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13760 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13764 digest
[0] = byte_swap_32 (digest
[0]);
13765 digest
[1] = byte_swap_32 (digest
[1]);
13767 return (PARSER_OK
);
13770 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13772 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13774 u32
*digest
= (u32
*) hash_buf
->digest
;
13776 salt_t
*salt
= hash_buf
->salt
;
13782 char *salt_pos
= input_buf
;
13784 char *hash_pos
= strchr (salt_pos
, '$');
13786 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13788 uint salt_len
= hash_pos
- salt_pos
;
13790 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13794 uint hash_len
= input_len
- 1 - salt_len
;
13796 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13804 for (uint i
= 0; i
< salt_len
; i
++)
13806 if (salt_pos
[i
] == ' ') continue;
13811 // SAP user names cannot be longer than 12 characters
13812 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13813 // so far nobody complained so we stay with this because it helps in optimization
13814 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13816 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13818 // SAP user name cannot start with ! or ?
13819 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13825 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13827 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13829 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13831 salt
->salt_len
= salt_len
;
13833 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13834 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13835 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13836 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13837 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13839 return (PARSER_OK
);
13842 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13844 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13846 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13848 u64
*digest
= (u64
*) hash_buf
->digest
;
13850 salt_t
*salt
= hash_buf
->salt
;
13852 char *iter_pos
= input_buf
+ 3;
13854 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13856 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13858 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13860 salt
->salt_iter
= salt_iter
;
13862 char *salt_pos
= iter_pos
+ 1;
13866 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13868 salt
->salt_len
= salt_len
;
13870 char *hash_pos
= salt_pos
+ salt_len
;
13872 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13876 char *tmp
= (char *) salt
->salt_buf_pc
;
13878 tmp
[0] = hash_pos
[42];
13882 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13883 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13884 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13885 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13891 return (PARSER_OK
);
13894 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13896 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13898 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13900 u32
*digest
= (u32
*) hash_buf
->digest
;
13902 salt_t
*salt
= hash_buf
->salt
;
13904 char *salt_buf
= input_buf
+ 6;
13906 uint salt_len
= 16;
13908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13914 salt
->salt_len
= salt_len
;
13916 char *hash_pos
= input_buf
+ 6 + 16;
13918 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13919 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13920 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13921 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13922 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13923 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13924 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13925 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13927 return (PARSER_OK
);
13930 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13932 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13934 u32
*digest
= (u32
*) hash_buf
->digest
;
13936 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13937 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13941 return (PARSER_OK
);
13944 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13946 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13948 u32
*digest
= (u32
*) hash_buf
->digest
;
13950 salt_t
*salt
= hash_buf
->salt
;
13952 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13954 char *saltbuf_pos
= input_buf
;
13956 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13958 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13960 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13962 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13963 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13965 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13969 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13971 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13973 char *salt_ptr
= (char *) saltbuf_pos
;
13974 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13979 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13981 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13984 rakp_ptr
[j
] = 0x80;
13986 rakp
->salt_len
= j
;
13988 for (i
= 0; i
< 64; i
++)
13990 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13993 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13994 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13995 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13996 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13997 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13998 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13999 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14000 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14002 salt
->salt_len
= 32; // muss min. 32 haben
14004 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14005 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14006 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14007 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14008 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14010 return (PARSER_OK
);
14013 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14015 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14017 u32
*digest
= (u32
*) hash_buf
->digest
;
14019 salt_t
*salt
= hash_buf
->salt
;
14021 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14023 char *salt_pos
= input_buf
+ 1;
14025 memcpy (salt
->salt_buf
, salt_pos
, 8);
14027 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14028 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14030 salt
->salt_len
= 8;
14032 char *hash_pos
= salt_pos
+ 8;
14034 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14035 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14036 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14037 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14038 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14040 digest
[0] -= SHA1M_A
;
14041 digest
[1] -= SHA1M_B
;
14042 digest
[2] -= SHA1M_C
;
14043 digest
[3] -= SHA1M_D
;
14044 digest
[4] -= SHA1M_E
;
14046 return (PARSER_OK
);
14049 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14051 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14053 u32
*digest
= (u32
*) hash_buf
->digest
;
14055 salt_t
*salt
= hash_buf
->salt
;
14057 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14058 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14059 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14060 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14062 digest
[0] = byte_swap_32 (digest
[0]);
14063 digest
[1] = byte_swap_32 (digest
[1]);
14064 digest
[2] = byte_swap_32 (digest
[2]);
14065 digest
[3] = byte_swap_32 (digest
[3]);
14067 digest
[0] -= MD5M_A
;
14068 digest
[1] -= MD5M_B
;
14069 digest
[2] -= MD5M_C
;
14070 digest
[3] -= MD5M_D
;
14072 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14074 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14076 u32
*salt_buf
= salt
->salt_buf
;
14078 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14079 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14080 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14081 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14083 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14084 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14085 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14086 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14088 salt
->salt_len
= 16 + 1;
14090 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14092 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14094 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14096 return (PARSER_OK
);
14099 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14101 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14103 u32
*digest
= (u32
*) hash_buf
->digest
;
14105 salt_t
*salt
= hash_buf
->salt
;
14107 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14113 char *hashbuf_pos
= input_buf
;
14115 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14117 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14119 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14121 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14125 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14127 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14129 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14131 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14135 char *databuf_pos
= strchr (iteration_pos
, ':');
14137 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14139 const uint iteration_len
= databuf_pos
- iteration_pos
;
14141 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14142 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14144 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14146 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14147 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14153 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14154 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14155 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14156 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14157 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14158 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14159 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14160 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14164 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14166 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14168 const char p0
= saltbuf_pos
[i
+ 0];
14169 const char p1
= saltbuf_pos
[i
+ 1];
14171 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14172 | hex_convert (p0
) << 4;
14175 salt
->salt_buf
[4] = 0x01000000;
14176 salt
->salt_buf
[5] = 0x80;
14178 salt
->salt_len
= saltbuf_len
/ 2;
14182 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14186 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14188 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14190 const char p0
= databuf_pos
[i
+ 0];
14191 const char p1
= databuf_pos
[i
+ 1];
14193 *databuf_ptr
++ = hex_convert (p1
) << 0
14194 | hex_convert (p0
) << 4;
14197 *databuf_ptr
++ = 0x80;
14199 for (uint i
= 0; i
< 512; i
++)
14201 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14204 cloudkey
->data_len
= databuf_len
/ 2;
14206 return (PARSER_OK
);
14209 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14211 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14213 u32
*digest
= (u32
*) hash_buf
->digest
;
14215 salt_t
*salt
= hash_buf
->salt
;
14221 char *hashbuf_pos
= input_buf
;
14223 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14225 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14227 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14229 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14233 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14235 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14237 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14239 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14241 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14245 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14247 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14249 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14251 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14253 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14257 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14259 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14260 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14262 // ok, the plan for this algorithm is the following:
14263 // we have 2 salts here, the domain-name and a random salt
14264 // while both are used in the initial transformation,
14265 // only the random salt is used in the following iterations
14266 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14267 // and one that includes only the real salt (stored into salt_buf[]).
14268 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14270 u8 tmp_buf
[100] = { 0 };
14272 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14274 memcpy (digest
, tmp_buf
, 20);
14276 digest
[0] = byte_swap_32 (digest
[0]);
14277 digest
[1] = byte_swap_32 (digest
[1]);
14278 digest
[2] = byte_swap_32 (digest
[2]);
14279 digest
[3] = byte_swap_32 (digest
[3]);
14280 digest
[4] = byte_swap_32 (digest
[4]);
14284 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14286 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14288 char *len_ptr
= NULL
;
14290 for (uint i
= 0; i
< domainbuf_len
; i
++)
14292 if (salt_buf_pc_ptr
[i
] == '.')
14294 len_ptr
= &salt_buf_pc_ptr
[i
];
14304 salt
->salt_buf_pc
[7] = domainbuf_len
;
14308 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14310 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14312 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14314 salt
->salt_len
= salt_len
;
14318 salt
->salt_iter
= atoi (iteration_pos
);
14320 return (PARSER_OK
);
14323 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14325 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14327 u32
*digest
= (u32
*) hash_buf
->digest
;
14329 salt_t
*salt
= hash_buf
->salt
;
14331 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14332 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14333 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14334 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14335 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14337 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14339 uint salt_len
= input_len
- 40 - 1;
14341 char *salt_buf
= input_buf
+ 40 + 1;
14343 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14349 salt
->salt_len
= salt_len
;
14351 return (PARSER_OK
);
14354 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14356 const u8 ascii_to_ebcdic
[] =
14358 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14359 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14360 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14361 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14362 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14363 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14364 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14365 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14366 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14367 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14368 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14369 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14370 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14371 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14372 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14373 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14376 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14378 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14380 u32
*digest
= (u32
*) hash_buf
->digest
;
14382 salt_t
*salt
= hash_buf
->salt
;
14384 char *salt_pos
= input_buf
+ 6 + 1;
14386 char *digest_pos
= strchr (salt_pos
, '*');
14388 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14390 uint salt_len
= digest_pos
- salt_pos
;
14392 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14394 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14396 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14401 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14403 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14405 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14407 salt
->salt_len
= salt_len
;
14409 for (uint i
= 0; i
< salt_len
; i
++)
14411 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14413 for (uint i
= salt_len
; i
< 8; i
++)
14415 salt_buf_pc_ptr
[i
] = 0x40;
14420 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14422 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14423 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14425 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14426 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14428 digest
[0] = byte_swap_32 (digest
[0]);
14429 digest
[1] = byte_swap_32 (digest
[1]);
14431 IP (digest
[0], digest
[1], tt
);
14433 digest
[0] = rotr32 (digest
[0], 29);
14434 digest
[1] = rotr32 (digest
[1], 29);
14438 return (PARSER_OK
);
14441 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14443 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14445 u32
*digest
= (u32
*) hash_buf
->digest
;
14447 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14448 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14449 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14450 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14452 digest
[0] = byte_swap_32 (digest
[0]);
14453 digest
[1] = byte_swap_32 (digest
[1]);
14454 digest
[2] = byte_swap_32 (digest
[2]);
14455 digest
[3] = byte_swap_32 (digest
[3]);
14457 return (PARSER_OK
);
14460 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14462 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14464 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14466 u32
*digest
= (u32
*) hash_buf
->digest
;
14468 salt_t
*salt
= hash_buf
->salt
;
14470 u8 tmp_buf
[120] = { 0 };
14472 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14474 tmp_buf
[3] += -4; // dont ask!
14476 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14478 salt
->salt_len
= 5;
14480 memcpy (digest
, tmp_buf
+ 5, 9);
14482 // yes, only 9 byte are needed to crack, but 10 to display
14484 salt
->salt_buf_pc
[7] = input_buf
[20];
14486 return (PARSER_OK
);
14489 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14491 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14493 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14495 u32
*digest
= (u32
*) hash_buf
->digest
;
14497 salt_t
*salt
= hash_buf
->salt
;
14499 u8 tmp_buf
[120] = { 0 };
14501 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14503 tmp_buf
[3] += -4; // dont ask!
14507 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14509 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)
14513 char tmp_iter_buf
[11] = { 0 };
14515 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14517 tmp_iter_buf
[10] = 0;
14519 salt
->salt_iter
= atoi (tmp_iter_buf
);
14521 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14523 return (PARSER_SALT_ITERATION
);
14526 salt
->salt_iter
--; // first round in init
14528 // 2 additional bytes for display only
14530 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14531 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14535 memcpy (digest
, tmp_buf
+ 28, 8);
14537 digest
[0] = byte_swap_32 (digest
[0]);
14538 digest
[1] = byte_swap_32 (digest
[1]);
14542 return (PARSER_OK
);
14545 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14547 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14549 u32
*digest
= (u32
*) hash_buf
->digest
;
14551 salt_t
*salt
= hash_buf
->salt
;
14553 char *salt_buf_pos
= input_buf
;
14555 char *hash_buf_pos
= salt_buf_pos
+ 6;
14557 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14558 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14559 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14560 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14561 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14562 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14563 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14564 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14566 digest
[0] -= SHA256M_A
;
14567 digest
[1] -= SHA256M_B
;
14568 digest
[2] -= SHA256M_C
;
14569 digest
[3] -= SHA256M_D
;
14570 digest
[4] -= SHA256M_E
;
14571 digest
[5] -= SHA256M_F
;
14572 digest
[6] -= SHA256M_G
;
14573 digest
[7] -= SHA256M_H
;
14575 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14577 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14579 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14581 salt
->salt_len
= salt_len
;
14583 return (PARSER_OK
);
14586 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14588 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14590 u32
*digest
= (u32
*) hash_buf
->digest
;
14592 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14594 salt_t
*salt
= hash_buf
->salt
;
14596 char *salt_buf
= input_buf
+ 6;
14598 char *digest_buf
= strchr (salt_buf
, '$');
14600 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14602 uint salt_len
= digest_buf
- salt_buf
;
14604 digest_buf
++; // skip the '$' symbol
14606 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14608 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14610 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14612 salt
->salt_len
= salt_len
;
14614 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14615 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14616 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14617 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14619 digest
[0] = byte_swap_32 (digest
[0]);
14620 digest
[1] = byte_swap_32 (digest
[1]);
14621 digest
[2] = byte_swap_32 (digest
[2]);
14622 digest
[3] = byte_swap_32 (digest
[3]);
14624 digest
[0] -= MD5M_A
;
14625 digest
[1] -= MD5M_B
;
14626 digest
[2] -= MD5M_C
;
14627 digest
[3] -= MD5M_D
;
14629 return (PARSER_OK
);
14632 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14634 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14636 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14638 u32
*digest
= (u32
*) hash_buf
->digest
;
14640 salt_t
*salt
= hash_buf
->salt
;
14642 char *salt_buf
= input_buf
+ 3;
14644 char *digest_buf
= strchr (salt_buf
, '$');
14646 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14648 uint salt_len
= digest_buf
- salt_buf
;
14650 digest_buf
++; // skip the '$' symbol
14652 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14654 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14656 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14658 salt_buf_ptr
[salt_len
] = 0x2d;
14660 salt
->salt_len
= salt_len
+ 1;
14662 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14663 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14664 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14665 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14667 digest
[0] = byte_swap_32 (digest
[0]);
14668 digest
[1] = byte_swap_32 (digest
[1]);
14669 digest
[2] = byte_swap_32 (digest
[2]);
14670 digest
[3] = byte_swap_32 (digest
[3]);
14672 digest
[0] -= MD5M_A
;
14673 digest
[1] -= MD5M_B
;
14674 digest
[2] -= MD5M_C
;
14675 digest
[3] -= MD5M_D
;
14677 return (PARSER_OK
);
14680 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14682 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14684 u32
*digest
= (u32
*) hash_buf
->digest
;
14686 salt_t
*salt
= hash_buf
->salt
;
14688 u8 tmp_buf
[100] = { 0 };
14690 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14692 memcpy (digest
, tmp_buf
, 20);
14694 digest
[0] = byte_swap_32 (digest
[0]);
14695 digest
[1] = byte_swap_32 (digest
[1]);
14696 digest
[2] = byte_swap_32 (digest
[2]);
14697 digest
[3] = byte_swap_32 (digest
[3]);
14698 digest
[4] = byte_swap_32 (digest
[4]);
14700 digest
[0] -= SHA1M_A
;
14701 digest
[1] -= SHA1M_B
;
14702 digest
[2] -= SHA1M_C
;
14703 digest
[3] -= SHA1M_D
;
14704 digest
[4] -= SHA1M_E
;
14706 salt
->salt_buf
[0] = 0x80;
14708 salt
->salt_len
= 0;
14710 return (PARSER_OK
);
14713 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14715 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14717 u32
*digest
= (u32
*) hash_buf
->digest
;
14719 salt_t
*salt
= hash_buf
->salt
;
14721 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14722 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14723 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14724 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14726 digest
[0] = byte_swap_32 (digest
[0]);
14727 digest
[1] = byte_swap_32 (digest
[1]);
14728 digest
[2] = byte_swap_32 (digest
[2]);
14729 digest
[3] = byte_swap_32 (digest
[3]);
14731 digest
[0] -= MD5M_A
;
14732 digest
[1] -= MD5M_B
;
14733 digest
[2] -= MD5M_C
;
14734 digest
[3] -= MD5M_D
;
14736 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14738 uint salt_len
= input_len
- 32 - 1;
14740 char *salt_buf
= input_buf
+ 32 + 1;
14742 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14744 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14746 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14749 * add static "salt" part
14752 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14756 salt
->salt_len
= salt_len
;
14758 return (PARSER_OK
);
14761 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14763 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14765 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14767 u32
*digest
= (u32
*) hash_buf
->digest
;
14769 salt_t
*salt
= hash_buf
->salt
;
14771 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14777 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14779 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14781 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14783 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14785 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14789 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14791 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14793 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14795 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14799 char *keybuf_pos
= strchr (keylen_pos
, '$');
14801 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14803 uint keylen_len
= keybuf_pos
- keylen_pos
;
14805 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14809 char *databuf_pos
= strchr (keybuf_pos
, '$');
14811 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14813 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14815 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14819 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14821 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14827 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14828 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14829 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14830 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14832 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14833 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14834 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14835 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14837 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14838 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14839 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14840 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14842 salt
->salt_len
= 16;
14843 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14845 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14847 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14850 return (PARSER_OK
);
14853 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14855 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14857 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14859 u32
*digest
= (u32
*) hash_buf
->digest
;
14861 salt_t
*salt
= hash_buf
->salt
;
14867 // first is the N salt parameter
14869 char *N_pos
= input_buf
+ 6;
14871 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14875 salt
->scrypt_N
= atoi (N_pos
);
14879 char *r_pos
= strchr (N_pos
, ':');
14881 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14885 salt
->scrypt_r
= atoi (r_pos
);
14889 char *p_pos
= strchr (r_pos
, ':');
14891 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14895 salt
->scrypt_p
= atoi (p_pos
);
14899 char *saltbuf_pos
= strchr (p_pos
, ':');
14901 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14905 char *hash_pos
= strchr (saltbuf_pos
, ':');
14907 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14913 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14915 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14917 u8 tmp_buf
[33] = { 0 };
14919 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14921 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14923 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14925 salt
->salt_len
= tmp_len
;
14926 salt
->salt_iter
= 1;
14928 // digest - base64 decode
14930 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14932 tmp_len
= input_len
- (hash_pos
- input_buf
);
14934 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14936 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14938 memcpy (digest
, tmp_buf
, 32);
14940 return (PARSER_OK
);
14943 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14945 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14947 u32
*digest
= (u32
*) hash_buf
->digest
;
14949 salt_t
*salt
= hash_buf
->salt
;
14955 char decrypted
[76] = { 0 }; // iv + hash
14957 juniper_decrypt_hash (input_buf
, decrypted
);
14959 char *md5crypt_hash
= decrypted
+ 12;
14961 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14963 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14965 char *salt_pos
= md5crypt_hash
+ 3;
14967 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14969 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14971 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14975 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14977 return (PARSER_OK
);
14980 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14982 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14984 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14986 u32
*digest
= (u32
*) hash_buf
->digest
;
14988 salt_t
*salt
= hash_buf
->salt
;
14990 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14996 // first is *raw* salt
14998 char *salt_pos
= input_buf
+ 3;
15000 char *hash_pos
= strchr (salt_pos
, '$');
15002 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15004 uint salt_len
= hash_pos
- salt_pos
;
15006 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15010 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15012 memcpy (salt_buf_ptr
, salt_pos
, 14);
15014 salt_buf_ptr
[17] = 0x01;
15015 salt_buf_ptr
[18] = 0x80;
15017 // add some stuff to normal salt to make sorted happy
15019 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15020 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15021 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15022 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15024 salt
->salt_len
= salt_len
;
15025 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15027 // base64 decode hash
15029 u8 tmp_buf
[100] = { 0 };
15031 uint hash_len
= input_len
- 3 - salt_len
- 1;
15033 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15035 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15037 memcpy (digest
, tmp_buf
, 32);
15039 digest
[0] = byte_swap_32 (digest
[0]);
15040 digest
[1] = byte_swap_32 (digest
[1]);
15041 digest
[2] = byte_swap_32 (digest
[2]);
15042 digest
[3] = byte_swap_32 (digest
[3]);
15043 digest
[4] = byte_swap_32 (digest
[4]);
15044 digest
[5] = byte_swap_32 (digest
[5]);
15045 digest
[6] = byte_swap_32 (digest
[6]);
15046 digest
[7] = byte_swap_32 (digest
[7]);
15048 return (PARSER_OK
);
15051 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15053 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15055 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15057 u32
*digest
= (u32
*) hash_buf
->digest
;
15059 salt_t
*salt
= hash_buf
->salt
;
15065 // first is *raw* salt
15067 char *salt_pos
= input_buf
+ 3;
15069 char *hash_pos
= strchr (salt_pos
, '$');
15071 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15073 uint salt_len
= hash_pos
- salt_pos
;
15075 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15077 salt
->salt_len
= salt_len
;
15080 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15082 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15083 salt_buf_ptr
[salt_len
] = 0;
15085 // base64 decode hash
15087 u8 tmp_buf
[100] = { 0 };
15089 uint hash_len
= input_len
- 3 - salt_len
- 1;
15091 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15093 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15095 memcpy (digest
, tmp_buf
, 32);
15098 salt
->scrypt_N
= 16384;
15099 salt
->scrypt_r
= 1;
15100 salt
->scrypt_p
= 1;
15101 salt
->salt_iter
= 1;
15103 return (PARSER_OK
);
15106 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15108 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15110 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15112 u32
*digest
= (u32
*) hash_buf
->digest
;
15114 salt_t
*salt
= hash_buf
->salt
;
15116 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15122 char *version_pos
= input_buf
+ 8 + 1;
15124 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15126 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15128 u32 version_len
= verifierHashSize_pos
- version_pos
;
15130 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15132 verifierHashSize_pos
++;
15134 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15136 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15138 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15140 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15144 char *saltSize_pos
= strchr (keySize_pos
, '*');
15146 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15148 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15150 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15154 char *osalt_pos
= strchr (saltSize_pos
, '*');
15156 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15158 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15160 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15164 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15166 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15168 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15170 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15172 encryptedVerifier_pos
++;
15174 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15176 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15178 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15180 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15182 encryptedVerifierHash_pos
++;
15184 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;
15186 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15188 const uint version
= atoi (version_pos
);
15190 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15192 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15194 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15196 const uint keySize
= atoi (keySize_pos
);
15198 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15200 office2007
->keySize
= keySize
;
15202 const uint saltSize
= atoi (saltSize_pos
);
15204 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15210 salt
->salt_len
= 16;
15211 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15213 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15214 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15215 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15216 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15222 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15223 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15224 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15225 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15227 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15228 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15229 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15230 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15231 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15237 digest
[0] = office2007
->encryptedVerifierHash
[0];
15238 digest
[1] = office2007
->encryptedVerifierHash
[1];
15239 digest
[2] = office2007
->encryptedVerifierHash
[2];
15240 digest
[3] = office2007
->encryptedVerifierHash
[3];
15242 return (PARSER_OK
);
15245 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15247 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15249 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15251 u32
*digest
= (u32
*) hash_buf
->digest
;
15253 salt_t
*salt
= hash_buf
->salt
;
15255 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15261 char *version_pos
= input_buf
+ 8 + 1;
15263 char *spinCount_pos
= strchr (version_pos
, '*');
15265 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15267 u32 version_len
= spinCount_pos
- version_pos
;
15269 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15273 char *keySize_pos
= strchr (spinCount_pos
, '*');
15275 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15277 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15279 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15283 char *saltSize_pos
= strchr (keySize_pos
, '*');
15285 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15287 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15289 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15293 char *osalt_pos
= strchr (saltSize_pos
, '*');
15295 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15297 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15299 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15303 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15305 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15307 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15309 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15311 encryptedVerifier_pos
++;
15313 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15315 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15317 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15319 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15321 encryptedVerifierHash_pos
++;
15323 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;
15325 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15327 const uint version
= atoi (version_pos
);
15329 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15331 const uint spinCount
= atoi (spinCount_pos
);
15333 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15335 const uint keySize
= atoi (keySize_pos
);
15337 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15339 const uint saltSize
= atoi (saltSize_pos
);
15341 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15347 salt
->salt_len
= 16;
15348 salt
->salt_iter
= spinCount
;
15350 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15351 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15352 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15353 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15359 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15360 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15361 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15362 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15364 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15365 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15366 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15367 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15368 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15369 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15370 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15371 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15377 digest
[0] = office2010
->encryptedVerifierHash
[0];
15378 digest
[1] = office2010
->encryptedVerifierHash
[1];
15379 digest
[2] = office2010
->encryptedVerifierHash
[2];
15380 digest
[3] = office2010
->encryptedVerifierHash
[3];
15382 return (PARSER_OK
);
15385 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15387 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15389 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15391 u32
*digest
= (u32
*) hash_buf
->digest
;
15393 salt_t
*salt
= hash_buf
->salt
;
15395 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15401 char *version_pos
= input_buf
+ 8 + 1;
15403 char *spinCount_pos
= strchr (version_pos
, '*');
15405 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15407 u32 version_len
= spinCount_pos
- version_pos
;
15409 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15413 char *keySize_pos
= strchr (spinCount_pos
, '*');
15415 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15417 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15419 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15423 char *saltSize_pos
= strchr (keySize_pos
, '*');
15425 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15427 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15429 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15433 char *osalt_pos
= strchr (saltSize_pos
, '*');
15435 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15437 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15439 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15443 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15445 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15447 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15449 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15451 encryptedVerifier_pos
++;
15453 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15455 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15457 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15459 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15461 encryptedVerifierHash_pos
++;
15463 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15465 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15467 const uint version
= atoi (version_pos
);
15469 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15471 const uint spinCount
= atoi (spinCount_pos
);
15473 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15475 const uint keySize
= atoi (keySize_pos
);
15477 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15479 const uint saltSize
= atoi (saltSize_pos
);
15481 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15487 salt
->salt_len
= 16;
15488 salt
->salt_iter
= spinCount
;
15490 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15491 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15492 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15493 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15499 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15500 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15501 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15502 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15504 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15505 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15506 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15507 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15508 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15509 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15510 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15511 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15517 digest
[0] = office2013
->encryptedVerifierHash
[0];
15518 digest
[1] = office2013
->encryptedVerifierHash
[1];
15519 digest
[2] = office2013
->encryptedVerifierHash
[2];
15520 digest
[3] = office2013
->encryptedVerifierHash
[3];
15522 return (PARSER_OK
);
15525 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15527 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15529 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15531 u32
*digest
= (u32
*) hash_buf
->digest
;
15533 salt_t
*salt
= hash_buf
->salt
;
15535 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15541 char *version_pos
= input_buf
+ 11;
15543 char *osalt_pos
= strchr (version_pos
, '*');
15545 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15547 u32 version_len
= osalt_pos
- version_pos
;
15549 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15553 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15555 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15557 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15559 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15561 encryptedVerifier_pos
++;
15563 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15565 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15567 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15569 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15571 encryptedVerifierHash_pos
++;
15573 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15575 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15577 const uint version
= *version_pos
- 0x30;
15579 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15585 oldoffice01
->version
= version
;
15587 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15588 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15589 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15590 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15592 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15593 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15594 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15595 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15597 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15598 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15599 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15600 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15602 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15603 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15604 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15605 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15611 salt
->salt_len
= 16;
15613 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15614 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15615 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15616 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15618 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15619 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15620 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15621 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15623 // this is a workaround as office produces multiple documents with the same salt
15625 salt
->salt_len
+= 32;
15627 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15628 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15629 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15630 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15631 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15632 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15633 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15634 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15640 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15641 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15642 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15643 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15645 return (PARSER_OK
);
15648 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15650 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15653 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15655 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15657 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15659 u32
*digest
= (u32
*) hash_buf
->digest
;
15661 salt_t
*salt
= hash_buf
->salt
;
15663 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15669 char *version_pos
= input_buf
+ 11;
15671 char *osalt_pos
= strchr (version_pos
, '*');
15673 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15675 u32 version_len
= osalt_pos
- version_pos
;
15677 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15681 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15683 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15685 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15687 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15689 encryptedVerifier_pos
++;
15691 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15693 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15695 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15697 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15699 encryptedVerifierHash_pos
++;
15701 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15703 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15705 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15707 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15711 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15713 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15715 const uint version
= *version_pos
- 0x30;
15717 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15723 oldoffice01
->version
= version
;
15725 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15726 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15727 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15728 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15730 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15731 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15732 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15733 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15735 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15736 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15737 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15738 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15740 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15741 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15742 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15743 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15745 oldoffice01
->rc4key
[1] = 0;
15746 oldoffice01
->rc4key
[0] = 0;
15748 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15749 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15750 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15751 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15752 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15753 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15754 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15755 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15756 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15757 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15759 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15760 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15766 salt
->salt_len
= 16;
15768 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15769 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15770 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15771 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15773 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15774 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15775 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15776 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15778 // this is a workaround as office produces multiple documents with the same salt
15780 salt
->salt_len
+= 32;
15782 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15783 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15784 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15785 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15786 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15787 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15788 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15789 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15795 digest
[0] = oldoffice01
->rc4key
[0];
15796 digest
[1] = oldoffice01
->rc4key
[1];
15800 return (PARSER_OK
);
15803 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15805 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15807 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15809 u32
*digest
= (u32
*) hash_buf
->digest
;
15811 salt_t
*salt
= hash_buf
->salt
;
15813 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15819 char *version_pos
= input_buf
+ 11;
15821 char *osalt_pos
= strchr (version_pos
, '*');
15823 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15825 u32 version_len
= osalt_pos
- version_pos
;
15827 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15831 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15833 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15835 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15837 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15839 encryptedVerifier_pos
++;
15841 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15843 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15845 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15847 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15849 encryptedVerifierHash_pos
++;
15851 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15853 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15855 const uint version
= *version_pos
- 0x30;
15857 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15863 oldoffice34
->version
= version
;
15865 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15866 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15867 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15868 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15870 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15871 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15872 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15873 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15875 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15876 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15877 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15878 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15879 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15881 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15882 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15883 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15884 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15885 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15891 salt
->salt_len
= 16;
15893 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15894 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15895 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15896 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15898 // this is a workaround as office produces multiple documents with the same salt
15900 salt
->salt_len
+= 32;
15902 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15903 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15904 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15905 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15906 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15907 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15908 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15909 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15915 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15916 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15917 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15918 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15920 return (PARSER_OK
);
15923 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15925 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15927 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15930 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15932 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15934 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15936 u32
*digest
= (u32
*) hash_buf
->digest
;
15938 salt_t
*salt
= hash_buf
->salt
;
15940 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15946 char *version_pos
= input_buf
+ 11;
15948 char *osalt_pos
= strchr (version_pos
, '*');
15950 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15952 u32 version_len
= osalt_pos
- version_pos
;
15954 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15958 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15960 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15962 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15964 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15966 encryptedVerifier_pos
++;
15968 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15970 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15972 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15974 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15976 encryptedVerifierHash_pos
++;
15978 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15980 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15982 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15984 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15988 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15990 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15992 const uint version
= *version_pos
- 0x30;
15994 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16000 oldoffice34
->version
= version
;
16002 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16003 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16004 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16005 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16007 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16008 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16009 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16010 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16012 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16013 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16014 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16015 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16016 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16018 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16019 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16020 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16021 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16022 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16024 oldoffice34
->rc4key
[1] = 0;
16025 oldoffice34
->rc4key
[0] = 0;
16027 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16028 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16029 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16030 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16031 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16032 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16033 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16034 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16035 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16036 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16038 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16039 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16045 salt
->salt_len
= 16;
16047 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16048 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16049 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16050 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16052 // this is a workaround as office produces multiple documents with the same salt
16054 salt
->salt_len
+= 32;
16056 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16057 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16058 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16059 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16060 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16061 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16062 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16063 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16069 digest
[0] = oldoffice34
->rc4key
[0];
16070 digest
[1] = oldoffice34
->rc4key
[1];
16074 return (PARSER_OK
);
16077 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16079 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16081 u32
*digest
= (u32
*) hash_buf
->digest
;
16083 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16084 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16085 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16086 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16088 digest
[0] = byte_swap_32 (digest
[0]);
16089 digest
[1] = byte_swap_32 (digest
[1]);
16090 digest
[2] = byte_swap_32 (digest
[2]);
16091 digest
[3] = byte_swap_32 (digest
[3]);
16093 return (PARSER_OK
);
16096 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16098 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16100 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16102 u32
*digest
= (u32
*) hash_buf
->digest
;
16104 salt_t
*salt
= hash_buf
->salt
;
16106 char *signature_pos
= input_buf
;
16108 char *salt_pos
= strchr (signature_pos
, '$');
16110 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16112 u32 signature_len
= salt_pos
- signature_pos
;
16114 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16118 char *hash_pos
= strchr (salt_pos
, '$');
16120 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16122 u32 salt_len
= hash_pos
- salt_pos
;
16124 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16128 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16130 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16132 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16133 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16134 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16135 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16136 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16138 digest
[0] -= SHA1M_A
;
16139 digest
[1] -= SHA1M_B
;
16140 digest
[2] -= SHA1M_C
;
16141 digest
[3] -= SHA1M_D
;
16142 digest
[4] -= SHA1M_E
;
16144 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16146 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16148 salt
->salt_len
= salt_len
;
16150 return (PARSER_OK
);
16153 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16155 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16157 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16159 u32
*digest
= (u32
*) hash_buf
->digest
;
16161 salt_t
*salt
= hash_buf
->salt
;
16163 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16169 char *iter_pos
= input_buf
+ 14;
16171 const int iter
= atoi (iter_pos
);
16173 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16175 salt
->salt_iter
= iter
- 1;
16177 char *salt_pos
= strchr (iter_pos
, '$');
16179 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16183 char *hash_pos
= strchr (salt_pos
, '$');
16185 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16187 const uint salt_len
= hash_pos
- salt_pos
;
16191 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16193 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16195 salt
->salt_len
= salt_len
;
16197 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16198 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16200 // add some stuff to normal salt to make sorted happy
16202 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16203 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16204 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16205 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16206 salt
->salt_buf
[4] = salt
->salt_iter
;
16208 // base64 decode hash
16210 u8 tmp_buf
[100] = { 0 };
16212 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16214 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16216 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16218 memcpy (digest
, tmp_buf
, 32);
16220 digest
[0] = byte_swap_32 (digest
[0]);
16221 digest
[1] = byte_swap_32 (digest
[1]);
16222 digest
[2] = byte_swap_32 (digest
[2]);
16223 digest
[3] = byte_swap_32 (digest
[3]);
16224 digest
[4] = byte_swap_32 (digest
[4]);
16225 digest
[5] = byte_swap_32 (digest
[5]);
16226 digest
[6] = byte_swap_32 (digest
[6]);
16227 digest
[7] = byte_swap_32 (digest
[7]);
16229 return (PARSER_OK
);
16232 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16234 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16236 u32
*digest
= (u32
*) hash_buf
->digest
;
16238 salt_t
*salt
= hash_buf
->salt
;
16240 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16241 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16245 digest
[0] = byte_swap_32 (digest
[0]);
16246 digest
[1] = byte_swap_32 (digest
[1]);
16248 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16249 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16250 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16252 char iter_c
= input_buf
[17];
16253 char iter_d
= input_buf
[19];
16255 // atm only defaults, let's see if there's more request
16256 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16257 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16259 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16261 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16262 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16263 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16264 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16266 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16267 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16268 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16269 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16271 salt
->salt_len
= 16;
16273 return (PARSER_OK
);
16276 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16278 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16280 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16282 u32
*digest
= (u32
*) hash_buf
->digest
;
16284 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16286 salt_t
*salt
= hash_buf
->salt
;
16288 char *salt_pos
= input_buf
+ 10;
16290 char *hash_pos
= strchr (salt_pos
, '$');
16292 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16294 uint salt_len
= hash_pos
- salt_pos
;
16298 uint hash_len
= input_len
- 10 - salt_len
- 1;
16300 // base64 decode salt
16302 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16304 u8 tmp_buf
[100] = { 0 };
16306 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16308 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16310 tmp_buf
[salt_len
] = 0x80;
16312 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16314 salt
->salt_len
= salt_len
;
16316 // base64 decode hash
16318 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16320 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16322 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16324 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16326 uint user_len
= hash_len
- 32;
16328 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16330 user_len
--; // skip the trailing space
16332 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16333 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16334 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16335 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16337 digest
[0] = byte_swap_32 (digest
[0]);
16338 digest
[1] = byte_swap_32 (digest
[1]);
16339 digest
[2] = byte_swap_32 (digest
[2]);
16340 digest
[3] = byte_swap_32 (digest
[3]);
16342 // store username for host only (output hash if cracked)
16344 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16345 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16347 return (PARSER_OK
);
16350 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16352 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16354 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16356 u32
*digest
= (u32
*) hash_buf
->digest
;
16358 salt_t
*salt
= hash_buf
->salt
;
16360 char *iter_pos
= input_buf
+ 10;
16362 u32 iter
= atoi (iter_pos
);
16366 return (PARSER_SALT_ITERATION
);
16369 iter
--; // first iteration is special
16371 salt
->salt_iter
= iter
;
16373 char *base64_pos
= strchr (iter_pos
, '}');
16375 if (base64_pos
== NULL
)
16377 return (PARSER_SIGNATURE_UNMATCHED
);
16382 // base64 decode salt
16384 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16386 u8 tmp_buf
[100] = { 0 };
16388 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16390 if (decoded_len
< 24)
16392 return (PARSER_SALT_LENGTH
);
16397 uint salt_len
= decoded_len
- 20;
16399 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16400 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16402 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16404 salt
->salt_len
= salt_len
;
16408 u32
*digest_ptr
= (u32
*) tmp_buf
;
16410 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16411 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16412 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16413 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16414 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16416 return (PARSER_OK
);
16419 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16421 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16423 u32
*digest
= (u32
*) hash_buf
->digest
;
16425 salt_t
*salt
= hash_buf
->salt
;
16427 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16428 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16429 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16430 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16431 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16433 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16435 uint salt_len
= input_len
- 40 - 1;
16437 char *salt_buf
= input_buf
+ 40 + 1;
16439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16441 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16443 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16445 salt
->salt_len
= salt_len
;
16447 return (PARSER_OK
);
16450 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16452 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16454 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16456 u32
*digest
= (u32
*) hash_buf
->digest
;
16458 salt_t
*salt
= hash_buf
->salt
;
16460 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16466 char *V_pos
= input_buf
+ 5;
16468 char *R_pos
= strchr (V_pos
, '*');
16470 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16472 u32 V_len
= R_pos
- V_pos
;
16476 char *bits_pos
= strchr (R_pos
, '*');
16478 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16480 u32 R_len
= bits_pos
- R_pos
;
16484 char *P_pos
= strchr (bits_pos
, '*');
16486 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16488 u32 bits_len
= P_pos
- bits_pos
;
16492 char *enc_md_pos
= strchr (P_pos
, '*');
16494 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16496 u32 P_len
= enc_md_pos
- P_pos
;
16500 char *id_len_pos
= strchr (enc_md_pos
, '*');
16502 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16504 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16508 char *id_buf_pos
= strchr (id_len_pos
, '*');
16510 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16512 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16516 char *u_len_pos
= strchr (id_buf_pos
, '*');
16518 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16520 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16522 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16526 char *u_buf_pos
= strchr (u_len_pos
, '*');
16528 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16530 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16534 char *o_len_pos
= strchr (u_buf_pos
, '*');
16536 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16538 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16540 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16544 char *o_buf_pos
= strchr (o_len_pos
, '*');
16546 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16548 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16552 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;
16554 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16558 const int V
= atoi (V_pos
);
16559 const int R
= atoi (R_pos
);
16560 const int P
= atoi (P_pos
);
16562 if (V
!= 1) return (PARSER_SALT_VALUE
);
16563 if (R
!= 2) return (PARSER_SALT_VALUE
);
16565 const int enc_md
= atoi (enc_md_pos
);
16567 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16569 const int id_len
= atoi (id_len_pos
);
16570 const int u_len
= atoi (u_len_pos
);
16571 const int o_len
= atoi (o_len_pos
);
16573 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16574 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16575 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16577 const int bits
= atoi (bits_pos
);
16579 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16581 // copy data to esalt
16587 pdf
->enc_md
= enc_md
;
16589 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16590 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16591 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16592 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16593 pdf
->id_len
= id_len
;
16595 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16596 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16597 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16598 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16599 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16600 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16601 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16602 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16603 pdf
->u_len
= u_len
;
16605 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16606 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16607 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16608 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16609 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16610 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16611 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16612 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16613 pdf
->o_len
= o_len
;
16615 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16616 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16617 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16618 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16620 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16621 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16622 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16623 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16624 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16625 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16626 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16627 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16629 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16630 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16631 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16632 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16633 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16634 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16635 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16636 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16638 // we use ID for salt, maybe needs to change, we will see...
16640 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16641 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16642 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16643 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16644 salt
->salt_len
= pdf
->id_len
;
16646 digest
[0] = pdf
->u_buf
[0];
16647 digest
[1] = pdf
->u_buf
[1];
16648 digest
[2] = pdf
->u_buf
[2];
16649 digest
[3] = pdf
->u_buf
[3];
16651 return (PARSER_OK
);
16654 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16656 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16659 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16661 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16663 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16665 u32
*digest
= (u32
*) hash_buf
->digest
;
16667 salt_t
*salt
= hash_buf
->salt
;
16669 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16675 char *V_pos
= input_buf
+ 5;
16677 char *R_pos
= strchr (V_pos
, '*');
16679 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16681 u32 V_len
= R_pos
- V_pos
;
16685 char *bits_pos
= strchr (R_pos
, '*');
16687 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16689 u32 R_len
= bits_pos
- R_pos
;
16693 char *P_pos
= strchr (bits_pos
, '*');
16695 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16697 u32 bits_len
= P_pos
- bits_pos
;
16701 char *enc_md_pos
= strchr (P_pos
, '*');
16703 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16705 u32 P_len
= enc_md_pos
- P_pos
;
16709 char *id_len_pos
= strchr (enc_md_pos
, '*');
16711 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16713 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16717 char *id_buf_pos
= strchr (id_len_pos
, '*');
16719 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16721 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16725 char *u_len_pos
= strchr (id_buf_pos
, '*');
16727 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16729 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16731 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16735 char *u_buf_pos
= strchr (u_len_pos
, '*');
16737 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16739 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16743 char *o_len_pos
= strchr (u_buf_pos
, '*');
16745 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16747 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16749 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16753 char *o_buf_pos
= strchr (o_len_pos
, '*');
16755 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16757 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16761 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16763 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16765 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16767 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16771 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;
16773 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16777 const int V
= atoi (V_pos
);
16778 const int R
= atoi (R_pos
);
16779 const int P
= atoi (P_pos
);
16781 if (V
!= 1) return (PARSER_SALT_VALUE
);
16782 if (R
!= 2) return (PARSER_SALT_VALUE
);
16784 const int enc_md
= atoi (enc_md_pos
);
16786 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16788 const int id_len
= atoi (id_len_pos
);
16789 const int u_len
= atoi (u_len_pos
);
16790 const int o_len
= atoi (o_len_pos
);
16792 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16793 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16794 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16796 const int bits
= atoi (bits_pos
);
16798 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16800 // copy data to esalt
16806 pdf
->enc_md
= enc_md
;
16808 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16809 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16810 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16811 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16812 pdf
->id_len
= id_len
;
16814 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16815 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16816 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16817 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16818 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16819 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16820 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16821 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16822 pdf
->u_len
= u_len
;
16824 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16825 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16826 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16827 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16828 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16829 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16830 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16831 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16832 pdf
->o_len
= o_len
;
16834 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16835 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16836 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16837 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16839 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16840 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16841 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16842 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16843 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16844 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16845 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16846 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16848 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16849 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16850 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16851 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16852 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16853 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16854 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16855 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16857 pdf
->rc4key
[1] = 0;
16858 pdf
->rc4key
[0] = 0;
16860 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16861 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16862 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16863 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16864 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16865 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16866 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16867 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16868 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16869 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16871 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16872 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16874 // we use ID for salt, maybe needs to change, we will see...
16876 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16877 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16878 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16879 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16880 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16881 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16882 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16883 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16884 salt
->salt_len
= pdf
->id_len
+ 16;
16886 digest
[0] = pdf
->rc4key
[0];
16887 digest
[1] = pdf
->rc4key
[1];
16891 return (PARSER_OK
);
16894 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16896 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16898 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16900 u32
*digest
= (u32
*) hash_buf
->digest
;
16902 salt_t
*salt
= hash_buf
->salt
;
16904 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16910 char *V_pos
= input_buf
+ 5;
16912 char *R_pos
= strchr (V_pos
, '*');
16914 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16916 u32 V_len
= R_pos
- V_pos
;
16920 char *bits_pos
= strchr (R_pos
, '*');
16922 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16924 u32 R_len
= bits_pos
- R_pos
;
16928 char *P_pos
= strchr (bits_pos
, '*');
16930 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16932 u32 bits_len
= P_pos
- bits_pos
;
16936 char *enc_md_pos
= strchr (P_pos
, '*');
16938 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16940 u32 P_len
= enc_md_pos
- P_pos
;
16944 char *id_len_pos
= strchr (enc_md_pos
, '*');
16946 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16948 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16952 char *id_buf_pos
= strchr (id_len_pos
, '*');
16954 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16956 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16960 char *u_len_pos
= strchr (id_buf_pos
, '*');
16962 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16964 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16966 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16970 char *u_buf_pos
= strchr (u_len_pos
, '*');
16972 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16974 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16978 char *o_len_pos
= strchr (u_buf_pos
, '*');
16980 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16982 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16984 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16988 char *o_buf_pos
= strchr (o_len_pos
, '*');
16990 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16992 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16996 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;
16998 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17002 const int V
= atoi (V_pos
);
17003 const int R
= atoi (R_pos
);
17004 const int P
= atoi (P_pos
);
17008 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17009 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17011 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17013 const int id_len
= atoi (id_len_pos
);
17014 const int u_len
= atoi (u_len_pos
);
17015 const int o_len
= atoi (o_len_pos
);
17017 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17019 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17020 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17022 const int bits
= atoi (bits_pos
);
17024 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17030 enc_md
= atoi (enc_md_pos
);
17033 // copy data to esalt
17039 pdf
->enc_md
= enc_md
;
17041 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17042 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17043 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17044 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17048 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17049 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17050 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17051 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17054 pdf
->id_len
= id_len
;
17056 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17057 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17058 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17059 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17060 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17061 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17062 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17063 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17064 pdf
->u_len
= u_len
;
17066 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17067 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17068 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17069 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17070 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17071 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17072 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17073 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17074 pdf
->o_len
= o_len
;
17076 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17077 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17078 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17079 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17083 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17084 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17085 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17086 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17089 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17090 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17091 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17092 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17093 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17094 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17095 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17096 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17098 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17099 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17100 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17101 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17102 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17103 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17104 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17105 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17107 // precompute rc4 data for later use
17123 uint salt_pc_block
[32] = { 0 };
17125 char *salt_pc_ptr
= (char *) salt_pc_block
;
17127 memcpy (salt_pc_ptr
, padding
, 32);
17128 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17130 uint salt_pc_digest
[4] = { 0 };
17132 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17134 pdf
->rc4data
[0] = salt_pc_digest
[0];
17135 pdf
->rc4data
[1] = salt_pc_digest
[1];
17137 // we use ID for salt, maybe needs to change, we will see...
17139 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17140 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17141 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17142 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17143 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17144 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17145 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17146 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17147 salt
->salt_len
= pdf
->id_len
+ 16;
17149 salt
->salt_iter
= ROUNDS_PDF14
;
17151 digest
[0] = pdf
->u_buf
[0];
17152 digest
[1] = pdf
->u_buf
[1];
17156 return (PARSER_OK
);
17159 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17161 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17163 if (ret
!= PARSER_OK
)
17168 u32
*digest
= (u32
*) hash_buf
->digest
;
17170 salt_t
*salt
= hash_buf
->salt
;
17172 digest
[0] -= SHA256M_A
;
17173 digest
[1] -= SHA256M_B
;
17174 digest
[2] -= SHA256M_C
;
17175 digest
[3] -= SHA256M_D
;
17176 digest
[4] -= SHA256M_E
;
17177 digest
[5] -= SHA256M_F
;
17178 digest
[6] -= SHA256M_G
;
17179 digest
[7] -= SHA256M_H
;
17181 salt
->salt_buf
[2] = 0x80;
17183 return (PARSER_OK
);
17186 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17188 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17190 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17192 u32
*digest
= (u32
*) hash_buf
->digest
;
17194 salt_t
*salt
= hash_buf
->salt
;
17196 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17202 char *V_pos
= input_buf
+ 5;
17204 char *R_pos
= strchr (V_pos
, '*');
17206 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17208 u32 V_len
= R_pos
- V_pos
;
17212 char *bits_pos
= strchr (R_pos
, '*');
17214 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17216 u32 R_len
= bits_pos
- R_pos
;
17220 char *P_pos
= strchr (bits_pos
, '*');
17222 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17224 u32 bits_len
= P_pos
- bits_pos
;
17228 char *enc_md_pos
= strchr (P_pos
, '*');
17230 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17232 u32 P_len
= enc_md_pos
- P_pos
;
17236 char *id_len_pos
= strchr (enc_md_pos
, '*');
17238 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17240 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17244 char *id_buf_pos
= strchr (id_len_pos
, '*');
17246 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17248 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17252 char *u_len_pos
= strchr (id_buf_pos
, '*');
17254 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17256 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17260 char *u_buf_pos
= strchr (u_len_pos
, '*');
17262 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17264 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17268 char *o_len_pos
= strchr (u_buf_pos
, '*');
17270 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17272 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17276 char *o_buf_pos
= strchr (o_len_pos
, '*');
17278 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17280 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17284 char *last
= strchr (o_buf_pos
, '*');
17286 if (last
== NULL
) last
= input_buf
+ input_len
;
17288 u32 o_buf_len
= last
- o_buf_pos
;
17292 const int V
= atoi (V_pos
);
17293 const int R
= atoi (R_pos
);
17297 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17298 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17300 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17302 const int bits
= atoi (bits_pos
);
17304 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17306 int enc_md
= atoi (enc_md_pos
);
17308 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17310 const uint id_len
= atoi (id_len_pos
);
17311 const uint u_len
= atoi (u_len_pos
);
17312 const uint o_len
= atoi (o_len_pos
);
17314 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17315 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17316 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17317 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17318 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17319 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17320 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17321 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17323 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17324 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17325 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17327 // copy data to esalt
17329 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17331 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17333 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17336 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17337 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17339 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17340 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17342 salt
->salt_len
= 8;
17343 salt
->salt_iter
= ROUNDS_PDF17L8
;
17345 digest
[0] = pdf
->u_buf
[0];
17346 digest
[1] = pdf
->u_buf
[1];
17347 digest
[2] = pdf
->u_buf
[2];
17348 digest
[3] = pdf
->u_buf
[3];
17349 digest
[4] = pdf
->u_buf
[4];
17350 digest
[5] = pdf
->u_buf
[5];
17351 digest
[6] = pdf
->u_buf
[6];
17352 digest
[7] = pdf
->u_buf
[7];
17354 return (PARSER_OK
);
17357 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17359 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17361 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17363 u32
*digest
= (u32
*) hash_buf
->digest
;
17365 salt_t
*salt
= hash_buf
->salt
;
17367 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17375 char *iter_pos
= input_buf
+ 7;
17377 u32 iter
= atoi (iter_pos
);
17379 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17380 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17382 // first is *raw* salt
17384 char *salt_pos
= strchr (iter_pos
, ':');
17386 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17390 char *hash_pos
= strchr (salt_pos
, ':');
17392 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17394 u32 salt_len
= hash_pos
- salt_pos
;
17396 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17400 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17402 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17406 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17408 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17410 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17412 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17413 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17415 salt
->salt_len
= salt_len
;
17416 salt
->salt_iter
= iter
- 1;
17420 u8 tmp_buf
[100] = { 0 };
17422 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17424 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17426 memcpy (digest
, tmp_buf
, 16);
17428 digest
[0] = byte_swap_32 (digest
[0]);
17429 digest
[1] = byte_swap_32 (digest
[1]);
17430 digest
[2] = byte_swap_32 (digest
[2]);
17431 digest
[3] = byte_swap_32 (digest
[3]);
17433 // add some stuff to normal salt to make sorted happy
17435 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17436 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17437 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17438 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17439 salt
->salt_buf
[4] = salt
->salt_iter
;
17441 return (PARSER_OK
);
17444 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17446 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17448 u32
*digest
= (u32
*) hash_buf
->digest
;
17450 salt_t
*salt
= hash_buf
->salt
;
17452 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17453 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17454 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17455 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17457 digest
[0] = byte_swap_32 (digest
[0]);
17458 digest
[1] = byte_swap_32 (digest
[1]);
17459 digest
[2] = byte_swap_32 (digest
[2]);
17460 digest
[3] = byte_swap_32 (digest
[3]);
17462 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17464 uint salt_len
= input_len
- 32 - 1;
17466 char *salt_buf
= input_buf
+ 32 + 1;
17468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17470 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17472 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17474 salt
->salt_len
= salt_len
;
17476 return (PARSER_OK
);
17479 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17481 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17483 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17485 u32
*digest
= (u32
*) hash_buf
->digest
;
17487 salt_t
*salt
= hash_buf
->salt
;
17489 char *user_pos
= input_buf
+ 10;
17491 char *salt_pos
= strchr (user_pos
, '*');
17493 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17497 char *hash_pos
= strchr (salt_pos
, '*');
17501 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17503 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17505 uint user_len
= salt_pos
- user_pos
- 1;
17507 uint salt_len
= hash_pos
- salt_pos
- 1;
17509 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17515 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17516 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17517 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17518 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17520 digest
[0] = byte_swap_32 (digest
[0]);
17521 digest
[1] = byte_swap_32 (digest
[1]);
17522 digest
[2] = byte_swap_32 (digest
[2]);
17523 digest
[3] = byte_swap_32 (digest
[3]);
17525 digest
[0] -= MD5M_A
;
17526 digest
[1] -= MD5M_B
;
17527 digest
[2] -= MD5M_C
;
17528 digest
[3] -= MD5M_D
;
17534 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17536 // first 4 bytes are the "challenge"
17538 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17539 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17540 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17541 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17543 // append the user name
17545 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17547 salt
->salt_len
= 4 + user_len
;
17549 return (PARSER_OK
);
17552 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17554 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17556 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17558 u32
*digest
= (u32
*) hash_buf
->digest
;
17560 salt_t
*salt
= hash_buf
->salt
;
17562 char *salt_pos
= input_buf
+ 9;
17564 char *hash_pos
= strchr (salt_pos
, '*');
17566 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17570 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17572 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17574 uint salt_len
= hash_pos
- salt_pos
- 1;
17576 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17582 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17583 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17584 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17585 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17586 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17592 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17594 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17596 salt
->salt_len
= salt_len
;
17598 return (PARSER_OK
);
17601 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17603 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17605 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17607 u32
*digest
= (u32
*) hash_buf
->digest
;
17609 salt_t
*salt
= hash_buf
->salt
;
17611 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17617 char *cry_master_len_pos
= input_buf
+ 9;
17619 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17621 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17623 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17625 cry_master_buf_pos
++;
17627 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17629 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17631 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17633 cry_salt_len_pos
++;
17635 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17637 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17639 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17641 cry_salt_buf_pos
++;
17643 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17645 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17647 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17651 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17653 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17655 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17659 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17661 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17663 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17667 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17669 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17671 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17673 public_key_len_pos
++;
17675 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17677 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17679 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17681 public_key_buf_pos
++;
17683 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;
17685 const uint cry_master_len
= atoi (cry_master_len_pos
);
17686 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17687 const uint ckey_len
= atoi (ckey_len_pos
);
17688 const uint public_key_len
= atoi (public_key_len_pos
);
17690 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17691 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17692 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17693 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17695 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17697 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17699 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17702 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17704 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17706 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17709 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17711 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17713 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17716 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17717 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17718 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17721 * store digest (should be unique enought, hopefully)
17724 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17725 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17726 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17727 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17733 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17735 const uint cry_rounds
= atoi (cry_rounds_pos
);
17737 salt
->salt_iter
= cry_rounds
- 1;
17739 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17741 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17743 salt
->salt_len
= salt_len
;
17745 return (PARSER_OK
);
17748 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17750 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17752 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17754 u32
*digest
= (u32
*) hash_buf
->digest
;
17756 salt_t
*salt
= hash_buf
->salt
;
17758 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17760 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17762 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17764 memcpy (temp_input_buf
, input_buf
, input_len
);
17768 char *URI_server_pos
= temp_input_buf
+ 6;
17770 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17772 if (URI_client_pos
== NULL
)
17774 myfree (temp_input_buf
);
17776 return (PARSER_SEPARATOR_UNMATCHED
);
17779 URI_client_pos
[0] = 0;
17782 uint URI_server_len
= strlen (URI_server_pos
);
17784 if (URI_server_len
> 512)
17786 myfree (temp_input_buf
);
17788 return (PARSER_SALT_LENGTH
);
17793 char *user_pos
= strchr (URI_client_pos
, '*');
17795 if (user_pos
== NULL
)
17797 myfree (temp_input_buf
);
17799 return (PARSER_SEPARATOR_UNMATCHED
);
17805 uint URI_client_len
= strlen (URI_client_pos
);
17807 if (URI_client_len
> 512)
17809 myfree (temp_input_buf
);
17811 return (PARSER_SALT_LENGTH
);
17816 char *realm_pos
= strchr (user_pos
, '*');
17818 if (realm_pos
== NULL
)
17820 myfree (temp_input_buf
);
17822 return (PARSER_SEPARATOR_UNMATCHED
);
17828 uint user_len
= strlen (user_pos
);
17830 if (user_len
> 116)
17832 myfree (temp_input_buf
);
17834 return (PARSER_SALT_LENGTH
);
17839 char *method_pos
= strchr (realm_pos
, '*');
17841 if (method_pos
== NULL
)
17843 myfree (temp_input_buf
);
17845 return (PARSER_SEPARATOR_UNMATCHED
);
17851 uint realm_len
= strlen (realm_pos
);
17853 if (realm_len
> 116)
17855 myfree (temp_input_buf
);
17857 return (PARSER_SALT_LENGTH
);
17862 char *URI_prefix_pos
= strchr (method_pos
, '*');
17864 if (URI_prefix_pos
== NULL
)
17866 myfree (temp_input_buf
);
17868 return (PARSER_SEPARATOR_UNMATCHED
);
17871 URI_prefix_pos
[0] = 0;
17874 uint method_len
= strlen (method_pos
);
17876 if (method_len
> 246)
17878 myfree (temp_input_buf
);
17880 return (PARSER_SALT_LENGTH
);
17885 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17887 if (URI_resource_pos
== NULL
)
17889 myfree (temp_input_buf
);
17891 return (PARSER_SEPARATOR_UNMATCHED
);
17894 URI_resource_pos
[0] = 0;
17895 URI_resource_pos
++;
17897 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17899 if (URI_prefix_len
> 245)
17901 myfree (temp_input_buf
);
17903 return (PARSER_SALT_LENGTH
);
17908 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17910 if (URI_suffix_pos
== NULL
)
17912 myfree (temp_input_buf
);
17914 return (PARSER_SEPARATOR_UNMATCHED
);
17917 URI_suffix_pos
[0] = 0;
17920 uint URI_resource_len
= strlen (URI_resource_pos
);
17922 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17924 myfree (temp_input_buf
);
17926 return (PARSER_SALT_LENGTH
);
17931 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17933 if (nonce_pos
== NULL
)
17935 myfree (temp_input_buf
);
17937 return (PARSER_SEPARATOR_UNMATCHED
);
17943 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17945 if (URI_suffix_len
> 245)
17947 myfree (temp_input_buf
);
17949 return (PARSER_SALT_LENGTH
);
17954 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17956 if (nonce_client_pos
== NULL
)
17958 myfree (temp_input_buf
);
17960 return (PARSER_SEPARATOR_UNMATCHED
);
17963 nonce_client_pos
[0] = 0;
17964 nonce_client_pos
++;
17966 uint nonce_len
= strlen (nonce_pos
);
17968 if (nonce_len
< 1 || nonce_len
> 50)
17970 myfree (temp_input_buf
);
17972 return (PARSER_SALT_LENGTH
);
17977 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17979 if (nonce_count_pos
== NULL
)
17981 myfree (temp_input_buf
);
17983 return (PARSER_SEPARATOR_UNMATCHED
);
17986 nonce_count_pos
[0] = 0;
17989 uint nonce_client_len
= strlen (nonce_client_pos
);
17991 if (nonce_client_len
> 50)
17993 myfree (temp_input_buf
);
17995 return (PARSER_SALT_LENGTH
);
18000 char *qop_pos
= strchr (nonce_count_pos
, '*');
18002 if (qop_pos
== NULL
)
18004 myfree (temp_input_buf
);
18006 return (PARSER_SEPARATOR_UNMATCHED
);
18012 uint nonce_count_len
= strlen (nonce_count_pos
);
18014 if (nonce_count_len
> 50)
18016 myfree (temp_input_buf
);
18018 return (PARSER_SALT_LENGTH
);
18023 char *directive_pos
= strchr (qop_pos
, '*');
18025 if (directive_pos
== NULL
)
18027 myfree (temp_input_buf
);
18029 return (PARSER_SEPARATOR_UNMATCHED
);
18032 directive_pos
[0] = 0;
18035 uint qop_len
= strlen (qop_pos
);
18039 myfree (temp_input_buf
);
18041 return (PARSER_SALT_LENGTH
);
18046 char *digest_pos
= strchr (directive_pos
, '*');
18048 if (digest_pos
== NULL
)
18050 myfree (temp_input_buf
);
18052 return (PARSER_SEPARATOR_UNMATCHED
);
18058 uint directive_len
= strlen (directive_pos
);
18060 if (directive_len
!= 3)
18062 myfree (temp_input_buf
);
18064 return (PARSER_SALT_LENGTH
);
18067 if (memcmp (directive_pos
, "MD5", 3))
18069 log_info ("ERROR: only the MD5 directive is currently supported\n");
18071 myfree (temp_input_buf
);
18073 return (PARSER_SIP_AUTH_DIRECTIVE
);
18077 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18082 uint md5_max_len
= 4 * 64;
18084 uint md5_remaining_len
= md5_max_len
;
18086 uint tmp_md5_buf
[64] = { 0 };
18088 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18090 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18092 md5_len
+= method_len
+ 1;
18093 tmp_md5_ptr
+= method_len
+ 1;
18095 if (URI_prefix_len
> 0)
18097 md5_remaining_len
= md5_max_len
- md5_len
;
18099 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18101 md5_len
+= URI_prefix_len
+ 1;
18102 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18105 md5_remaining_len
= md5_max_len
- md5_len
;
18107 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18109 md5_len
+= URI_resource_len
;
18110 tmp_md5_ptr
+= URI_resource_len
;
18112 if (URI_suffix_len
> 0)
18114 md5_remaining_len
= md5_max_len
- md5_len
;
18116 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18118 md5_len
+= 1 + URI_suffix_len
;
18121 uint tmp_digest
[4] = { 0 };
18123 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18125 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18126 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18127 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18128 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18134 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18136 uint esalt_len
= 0;
18138 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18140 // there are 2 possibilities for the esalt:
18142 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18144 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18146 if (esalt_len
> max_esalt_len
)
18148 myfree (temp_input_buf
);
18150 return (PARSER_SALT_LENGTH
);
18153 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18165 esalt_len
= 1 + nonce_len
+ 1 + 32;
18167 if (esalt_len
> max_esalt_len
)
18169 myfree (temp_input_buf
);
18171 return (PARSER_SALT_LENGTH
);
18174 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18182 // add 0x80 to esalt
18184 esalt_buf_ptr
[esalt_len
] = 0x80;
18186 sip
->esalt_len
= esalt_len
;
18192 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18194 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18196 uint max_salt_len
= 119;
18198 if (salt_len
> max_salt_len
)
18200 myfree (temp_input_buf
);
18202 return (PARSER_SALT_LENGTH
);
18205 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18207 sip
->salt_len
= salt_len
;
18210 * fake salt (for sorting)
18213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18217 uint fake_salt_len
= salt_len
;
18219 if (fake_salt_len
> max_salt_len
)
18221 fake_salt_len
= max_salt_len
;
18224 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18226 salt
->salt_len
= fake_salt_len
;
18232 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18233 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18234 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18235 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18237 digest
[0] = byte_swap_32 (digest
[0]);
18238 digest
[1] = byte_swap_32 (digest
[1]);
18239 digest
[2] = byte_swap_32 (digest
[2]);
18240 digest
[3] = byte_swap_32 (digest
[3]);
18242 myfree (temp_input_buf
);
18244 return (PARSER_OK
);
18247 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18249 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18251 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18253 u32
*digest
= (u32
*) hash_buf
->digest
;
18255 salt_t
*salt
= hash_buf
->salt
;
18259 char *digest_pos
= input_buf
;
18261 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18268 char *salt_buf
= input_buf
+ 8 + 1;
18272 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18274 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18276 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18278 salt
->salt_len
= salt_len
;
18280 return (PARSER_OK
);
18283 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18285 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18287 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18289 u32
*digest
= (u32
*) hash_buf
->digest
;
18291 salt_t
*salt
= hash_buf
->salt
;
18293 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18299 char *p_buf_pos
= input_buf
+ 4;
18301 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18303 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18305 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18307 NumCyclesPower_pos
++;
18309 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18311 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18313 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18317 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18319 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18321 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18325 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18327 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18329 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18333 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18335 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18337 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18341 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18343 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18345 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18349 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18351 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18353 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18357 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18359 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18361 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18365 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18367 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18369 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18373 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;
18375 const uint iter
= atoi (NumCyclesPower_pos
);
18376 const uint crc
= atoi (crc_buf_pos
);
18377 const uint p_buf
= atoi (p_buf_pos
);
18378 const uint salt_len
= atoi (salt_len_pos
);
18379 const uint iv_len
= atoi (iv_len_pos
);
18380 const uint unpack_size
= atoi (unpack_size_pos
);
18381 const uint data_len
= atoi (data_len_pos
);
18387 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18388 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18390 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18392 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18394 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18400 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18401 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18402 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18403 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18405 seven_zip
->iv_len
= iv_len
;
18407 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18409 seven_zip
->salt_len
= 0;
18411 seven_zip
->crc
= crc
;
18413 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18415 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18417 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18420 seven_zip
->data_len
= data_len
;
18422 seven_zip
->unpack_size
= unpack_size
;
18426 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18427 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18428 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18429 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18431 salt
->salt_len
= 16;
18433 salt
->salt_sign
[0] = iter
;
18435 salt
->salt_iter
= 1 << iter
;
18446 return (PARSER_OK
);
18449 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18451 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18453 u32
*digest
= (u32
*) hash_buf
->digest
;
18455 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18456 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18457 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18458 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18459 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18460 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18461 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18462 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18464 digest
[0] = byte_swap_32 (digest
[0]);
18465 digest
[1] = byte_swap_32 (digest
[1]);
18466 digest
[2] = byte_swap_32 (digest
[2]);
18467 digest
[3] = byte_swap_32 (digest
[3]);
18468 digest
[4] = byte_swap_32 (digest
[4]);
18469 digest
[5] = byte_swap_32 (digest
[5]);
18470 digest
[6] = byte_swap_32 (digest
[6]);
18471 digest
[7] = byte_swap_32 (digest
[7]);
18473 return (PARSER_OK
);
18476 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18478 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18480 u32
*digest
= (u32
*) hash_buf
->digest
;
18482 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18483 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18484 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18485 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18486 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18487 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18488 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18489 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18490 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18491 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18492 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18493 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18494 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18495 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18496 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18497 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18499 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18500 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18501 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18502 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18503 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18504 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18505 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18506 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18507 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18508 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18509 digest
[10] = byte_swap_32 (digest
[10]);
18510 digest
[11] = byte_swap_32 (digest
[11]);
18511 digest
[12] = byte_swap_32 (digest
[12]);
18512 digest
[13] = byte_swap_32 (digest
[13]);
18513 digest
[14] = byte_swap_32 (digest
[14]);
18514 digest
[15] = byte_swap_32 (digest
[15]);
18516 return (PARSER_OK
);
18519 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18521 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18523 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18525 u32
*digest
= (u32
*) hash_buf
->digest
;
18527 salt_t
*salt
= hash_buf
->salt
;
18529 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18537 char *iter_pos
= input_buf
+ 4;
18539 u32 iter
= atoi (iter_pos
);
18541 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18542 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18544 // first is *raw* salt
18546 char *salt_pos
= strchr (iter_pos
, ':');
18548 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18552 char *hash_pos
= strchr (salt_pos
, ':');
18554 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18556 u32 salt_len
= hash_pos
- salt_pos
;
18558 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18562 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18564 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18568 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18570 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18572 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18574 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18575 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18577 salt
->salt_len
= salt_len
;
18578 salt
->salt_iter
= iter
- 1;
18582 u8 tmp_buf
[100] = { 0 };
18584 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18586 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18588 memcpy (digest
, tmp_buf
, 16);
18590 // add some stuff to normal salt to make sorted happy
18592 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18593 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18594 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18595 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18596 salt
->salt_buf
[4] = salt
->salt_iter
;
18598 return (PARSER_OK
);
18601 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18603 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18605 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18607 u32
*digest
= (u32
*) hash_buf
->digest
;
18609 salt_t
*salt
= hash_buf
->salt
;
18611 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18619 char *iter_pos
= input_buf
+ 5;
18621 u32 iter
= atoi (iter_pos
);
18623 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18624 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18626 // first is *raw* salt
18628 char *salt_pos
= strchr (iter_pos
, ':');
18630 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18634 char *hash_pos
= strchr (salt_pos
, ':');
18636 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18638 u32 salt_len
= hash_pos
- salt_pos
;
18640 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18644 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18646 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18650 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18652 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18654 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18656 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18657 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18659 salt
->salt_len
= salt_len
;
18660 salt
->salt_iter
= iter
- 1;
18664 u8 tmp_buf
[100] = { 0 };
18666 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18668 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18670 memcpy (digest
, tmp_buf
, 16);
18672 digest
[0] = byte_swap_32 (digest
[0]);
18673 digest
[1] = byte_swap_32 (digest
[1]);
18674 digest
[2] = byte_swap_32 (digest
[2]);
18675 digest
[3] = byte_swap_32 (digest
[3]);
18677 // add some stuff to normal salt to make sorted happy
18679 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18680 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18681 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18682 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18683 salt
->salt_buf
[4] = salt
->salt_iter
;
18685 return (PARSER_OK
);
18688 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18690 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18692 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18694 u64
*digest
= (u64
*) hash_buf
->digest
;
18696 salt_t
*salt
= hash_buf
->salt
;
18698 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18706 char *iter_pos
= input_buf
+ 7;
18708 u32 iter
= atoi (iter_pos
);
18710 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18711 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18713 // first is *raw* salt
18715 char *salt_pos
= strchr (iter_pos
, ':');
18717 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18721 char *hash_pos
= strchr (salt_pos
, ':');
18723 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18725 u32 salt_len
= hash_pos
- salt_pos
;
18727 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18731 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18733 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18737 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18739 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18741 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18743 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18744 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18746 salt
->salt_len
= salt_len
;
18747 salt
->salt_iter
= iter
- 1;
18751 u8 tmp_buf
[100] = { 0 };
18753 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18755 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18757 memcpy (digest
, tmp_buf
, 64);
18759 digest
[0] = byte_swap_64 (digest
[0]);
18760 digest
[1] = byte_swap_64 (digest
[1]);
18761 digest
[2] = byte_swap_64 (digest
[2]);
18762 digest
[3] = byte_swap_64 (digest
[3]);
18763 digest
[4] = byte_swap_64 (digest
[4]);
18764 digest
[5] = byte_swap_64 (digest
[5]);
18765 digest
[6] = byte_swap_64 (digest
[6]);
18766 digest
[7] = byte_swap_64 (digest
[7]);
18768 // add some stuff to normal salt to make sorted happy
18770 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18771 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18772 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18773 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18774 salt
->salt_buf
[4] = salt
->salt_iter
;
18776 return (PARSER_OK
);
18779 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18781 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18783 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18785 uint
*digest
= (uint
*) hash_buf
->digest
;
18787 salt_t
*salt
= hash_buf
->salt
;
18793 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18795 char *hash_pos
= strchr (salt_pos
, '$');
18797 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18799 u32 salt_len
= hash_pos
- salt_pos
;
18801 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18805 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18807 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18811 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18812 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18830 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18831 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18833 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18834 salt
->salt_len
= 8;
18836 return (PARSER_OK
);
18839 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18841 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18843 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18845 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18847 if (c19
& 3) return (PARSER_HASH_VALUE
);
18849 salt_t
*salt
= hash_buf
->salt
;
18851 u32
*digest
= (u32
*) hash_buf
->digest
;
18855 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18856 | itoa64_to_int (input_buf
[2]) << 6
18857 | itoa64_to_int (input_buf
[3]) << 12
18858 | itoa64_to_int (input_buf
[4]) << 18;
18862 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18863 | itoa64_to_int (input_buf
[6]) << 6
18864 | itoa64_to_int (input_buf
[7]) << 12
18865 | itoa64_to_int (input_buf
[8]) << 18;
18867 salt
->salt_len
= 4;
18869 u8 tmp_buf
[100] = { 0 };
18871 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18873 memcpy (digest
, tmp_buf
, 8);
18877 IP (digest
[0], digest
[1], tt
);
18879 digest
[0] = rotr32 (digest
[0], 31);
18880 digest
[1] = rotr32 (digest
[1], 31);
18884 return (PARSER_OK
);
18887 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18889 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18891 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18893 u32
*digest
= (u32
*) hash_buf
->digest
;
18895 salt_t
*salt
= hash_buf
->salt
;
18901 char *type_pos
= input_buf
+ 6 + 1;
18903 char *salt_pos
= strchr (type_pos
, '*');
18905 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18907 u32 type_len
= salt_pos
- type_pos
;
18909 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18913 char *crypted_pos
= strchr (salt_pos
, '*');
18915 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18917 u32 salt_len
= crypted_pos
- salt_pos
;
18919 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18923 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18925 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18931 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18932 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18934 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18935 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18937 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18938 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18939 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18940 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18942 salt
->salt_len
= 24;
18943 salt
->salt_iter
= ROUNDS_RAR3
;
18945 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18946 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18948 digest
[0] = 0xc43d7b00;
18949 digest
[1] = 0x40070000;
18953 return (PARSER_OK
);
18956 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18958 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18960 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18962 u32
*digest
= (u32
*) hash_buf
->digest
;
18964 salt_t
*salt
= hash_buf
->salt
;
18966 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18972 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18974 char *param1_pos
= strchr (param0_pos
, '$');
18976 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18978 u32 param0_len
= param1_pos
- param0_pos
;
18982 char *param2_pos
= strchr (param1_pos
, '$');
18984 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18986 u32 param1_len
= param2_pos
- param1_pos
;
18990 char *param3_pos
= strchr (param2_pos
, '$');
18992 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18994 u32 param2_len
= param3_pos
- param2_pos
;
18998 char *param4_pos
= strchr (param3_pos
, '$');
19000 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19002 u32 param3_len
= param4_pos
- param3_pos
;
19006 char *param5_pos
= strchr (param4_pos
, '$');
19008 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19010 u32 param4_len
= param5_pos
- param4_pos
;
19014 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19016 char *salt_buf
= param1_pos
;
19017 char *iv
= param3_pos
;
19018 char *pswcheck
= param5_pos
;
19020 const uint salt_len
= atoi (param0_pos
);
19021 const uint iterations
= atoi (param2_pos
);
19022 const uint pswcheck_len
= atoi (param4_pos
);
19028 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19029 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19030 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19032 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19033 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19034 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19040 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19041 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19042 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19043 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19045 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19046 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19047 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19048 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19050 salt
->salt_len
= 16;
19052 salt
->salt_sign
[0] = iterations
;
19054 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19060 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19061 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19065 return (PARSER_OK
);
19068 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19070 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19072 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19074 u32
*digest
= (u32
*) hash_buf
->digest
;
19076 salt_t
*salt
= hash_buf
->salt
;
19078 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19085 char *account_pos
= input_buf
+ 11 + 1;
19091 if (account_pos
[0] == '*')
19095 data_pos
= strchr (account_pos
, '*');
19100 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19102 uint account_len
= data_pos
- account_pos
+ 1;
19104 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19109 data_len
= input_len
- 11 - 1 - account_len
- 2;
19111 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19115 /* assume $krb5tgs$23$checksum$edata2 */
19116 data_pos
= account_pos
;
19118 memcpy (krb5tgs
->account_info
, "**", 3);
19120 data_len
= input_len
- 11 - 1 - 1;
19123 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19125 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19127 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19129 const char p0
= data_pos
[i
+ 0];
19130 const char p1
= data_pos
[i
+ 1];
19132 *checksum_ptr
++ = hex_convert (p1
) << 0
19133 | hex_convert (p0
) << 4;
19136 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19138 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19141 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19143 const char p0
= data_pos
[i
+ 0];
19144 const char p1
= data_pos
[i
+ 1];
19145 *edata_ptr
++ = hex_convert (p1
) << 0
19146 | hex_convert (p0
) << 4;
19149 /* this is needed for hmac_md5 */
19150 *edata_ptr
++ = 0x80;
19152 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19153 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19154 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19155 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19157 salt
->salt_len
= 32;
19159 digest
[0] = krb5tgs
->checksum
[0];
19160 digest
[1] = krb5tgs
->checksum
[1];
19161 digest
[2] = krb5tgs
->checksum
[2];
19162 digest
[3] = krb5tgs
->checksum
[3];
19164 return (PARSER_OK
);
19167 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19169 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19171 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19173 u32
*digest
= (u32
*) hash_buf
->digest
;
19175 salt_t
*salt
= hash_buf
->salt
;
19182 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19186 char *wrapped_key_pos
;
19190 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19192 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19194 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19196 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19201 data_pos
= salt_pos
;
19203 wrapped_key_pos
= strchr (salt_pos
, '*');
19205 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19207 uint salt_len
= wrapped_key_pos
- salt_pos
;
19209 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19214 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19216 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19218 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19219 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19220 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19221 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19225 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19226 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19227 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19228 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19229 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19230 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19232 salt
->salt_len
= 40;
19234 digest
[0] = salt
->salt_buf
[0];
19235 digest
[1] = salt
->salt_buf
[1];
19236 digest
[2] = salt
->salt_buf
[2];
19237 digest
[3] = salt
->salt_buf
[3];
19239 return (PARSER_OK
);
19242 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19244 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19246 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19248 u32
*digest
= (u32
*) hash_buf
->digest
;
19250 salt_t
*salt
= hash_buf
->salt
;
19252 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19262 char *algorithm_pos
;
19264 char *final_random_seed_pos
;
19265 u32 final_random_seed_len
;
19267 char *transf_random_seed_pos
;
19268 u32 transf_random_seed_len
;
19273 /* default is no keyfile provided */
19274 char *keyfile_len_pos
;
19275 u32 keyfile_len
= 0;
19276 u32 is_keyfile_present
= 0;
19277 char *keyfile_inline_pos
;
19280 /* specific to version 1 */
19281 char *contents_len_pos
;
19283 char *contents_pos
;
19285 /* specific to version 2 */
19286 char *expected_bytes_pos
;
19287 u32 expected_bytes_len
;
19289 char *contents_hash_pos
;
19290 u32 contents_hash_len
;
19292 version_pos
= input_buf
+ 8 + 1 + 1;
19294 keepass
->version
= atoi (version_pos
);
19296 rounds_pos
= strchr (version_pos
, '*');
19298 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19302 salt
->salt_iter
= (atoi (rounds_pos
));
19304 algorithm_pos
= strchr (rounds_pos
, '*');
19306 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19310 keepass
->algorithm
= atoi (algorithm_pos
);
19312 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19314 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19316 final_random_seed_pos
++;
19318 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19319 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19320 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19321 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19323 if (keepass
->version
== 2)
19325 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19326 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19327 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19328 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19331 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19333 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19335 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19337 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19338 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19340 transf_random_seed_pos
++;
19342 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19343 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19344 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19345 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19346 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19347 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19348 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19349 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19351 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19353 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19355 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19357 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19361 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19362 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19363 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19364 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19366 if (keepass
->version
== 1)
19368 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19370 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19372 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19374 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19376 contents_hash_pos
++;
19378 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19379 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19380 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19381 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19382 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19383 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19384 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19385 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19387 /* get length of contents following */
19388 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19390 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19392 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19394 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19398 u32 inline_flag
= atoi (inline_flag_pos
);
19400 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19402 contents_len_pos
= strchr (inline_flag_pos
, '*');
19404 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19406 contents_len_pos
++;
19408 contents_len
= atoi (contents_len_pos
);
19410 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19412 contents_pos
= strchr (contents_len_pos
, '*');
19414 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19420 keepass
->contents_len
= contents_len
;
19422 contents_len
= contents_len
/ 4;
19424 keyfile_inline_pos
= strchr (contents_pos
, '*');
19426 u32 real_contents_len
;
19428 if (keyfile_inline_pos
== NULL
)
19429 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19432 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19433 keyfile_inline_pos
++;
19434 is_keyfile_present
= 1;
19437 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19439 for (i
= 0; i
< contents_len
; i
++)
19440 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19442 else if (keepass
->version
== 2)
19444 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19446 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19448 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19450 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19452 expected_bytes_pos
++;
19454 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19455 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19456 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19457 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19458 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19459 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19460 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19461 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19463 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19465 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19467 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19469 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19471 contents_hash_pos
++;
19473 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19474 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19475 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19476 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19477 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19478 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19479 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19480 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19482 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19484 if (keyfile_inline_pos
== NULL
)
19485 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19488 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19489 keyfile_inline_pos
++;
19490 is_keyfile_present
= 1;
19492 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19495 if (is_keyfile_present
!= 0)
19497 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19501 keyfile_len
= atoi (keyfile_len_pos
);
19503 keepass
->keyfile_len
= keyfile_len
;
19505 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19507 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19509 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19513 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19515 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19517 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19518 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19519 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19520 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19521 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19522 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19523 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19524 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19527 digest
[0] = keepass
->enc_iv
[0];
19528 digest
[1] = keepass
->enc_iv
[1];
19529 digest
[2] = keepass
->enc_iv
[2];
19530 digest
[3] = keepass
->enc_iv
[3];
19532 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19533 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19534 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19535 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19536 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19537 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19538 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19539 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19541 return (PARSER_OK
);
19544 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19546 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19548 u32
*digest
= (u32
*) hash_buf
->digest
;
19550 salt_t
*salt
= hash_buf
->salt
;
19552 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19553 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19554 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19555 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19556 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19557 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19558 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19559 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19561 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19563 uint salt_len
= input_len
- 64 - 1;
19565 char *salt_buf
= input_buf
+ 64 + 1;
19567 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19569 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19571 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19573 salt
->salt_len
= salt_len
;
19576 * we can precompute the first sha256 transform
19579 uint w
[16] = { 0 };
19581 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19582 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19583 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19584 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19585 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19586 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19587 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19588 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19589 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19590 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19591 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19592 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19593 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19594 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19595 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19596 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19598 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19600 sha256_64 (w
, pc256
);
19602 salt
->salt_buf_pc
[0] = pc256
[0];
19603 salt
->salt_buf_pc
[1] = pc256
[1];
19604 salt
->salt_buf_pc
[2] = pc256
[2];
19605 salt
->salt_buf_pc
[3] = pc256
[3];
19606 salt
->salt_buf_pc
[4] = pc256
[4];
19607 salt
->salt_buf_pc
[5] = pc256
[5];
19608 salt
->salt_buf_pc
[6] = pc256
[6];
19609 salt
->salt_buf_pc
[7] = pc256
[7];
19611 digest
[0] -= pc256
[0];
19612 digest
[1] -= pc256
[1];
19613 digest
[2] -= pc256
[2];
19614 digest
[3] -= pc256
[3];
19615 digest
[4] -= pc256
[4];
19616 digest
[5] -= pc256
[5];
19617 digest
[6] -= pc256
[6];
19618 digest
[7] -= pc256
[7];
19620 return (PARSER_OK
);
19623 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19625 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19627 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19629 u32
*digest
= (u32
*) hash_buf
->digest
;
19631 salt_t
*salt
= hash_buf
->salt
;
19637 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19639 char *data_buf_pos
= strchr (data_len_pos
, '$');
19641 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19643 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19645 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19646 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19650 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19652 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19654 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19656 u32 data_len
= atoi (data_len_pos
);
19658 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19664 char *salt_pos
= data_buf_pos
;
19666 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19667 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19668 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19669 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19671 // this is actually the CT, which is also the hash later (if matched)
19673 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19674 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19675 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19676 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19678 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19680 salt
->salt_iter
= 10 - 1;
19686 digest
[0] = salt
->salt_buf
[4];
19687 digest
[1] = salt
->salt_buf
[5];
19688 digest
[2] = salt
->salt_buf
[6];
19689 digest
[3] = salt
->salt_buf
[7];
19691 return (PARSER_OK
);
19694 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19696 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19698 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19700 u32
*digest
= (u32
*) hash_buf
->digest
;
19702 salt_t
*salt
= hash_buf
->salt
;
19708 char *salt_pos
= input_buf
+ 11 + 1;
19710 char *iter_pos
= strchr (salt_pos
, ',');
19712 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19714 u32 salt_len
= iter_pos
- salt_pos
;
19716 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19720 char *hash_pos
= strchr (iter_pos
, ',');
19722 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19724 u32 iter_len
= hash_pos
- iter_pos
;
19726 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19730 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19732 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19738 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19739 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19740 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19741 salt
->salt_buf
[3] = 0x00018000;
19743 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19744 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19745 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19746 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19748 salt
->salt_len
= salt_len
/ 2;
19750 salt
->salt_iter
= atoi (iter_pos
) - 1;
19756 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19757 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19758 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19759 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19760 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19761 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19762 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19763 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19765 return (PARSER_OK
);
19768 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19770 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19772 u32
*digest
= (u32
*) hash_buf
->digest
;
19774 salt_t
*salt
= hash_buf
->salt
;
19780 char *hash_pos
= input_buf
+ 64;
19781 char *salt1_pos
= input_buf
+ 128;
19782 char *salt2_pos
= input_buf
;
19788 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19789 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19790 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19791 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19793 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19794 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19795 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19796 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19798 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19799 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19800 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19801 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19803 salt
->salt_len
= 48;
19805 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19811 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19812 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19813 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19814 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19815 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19816 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19817 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19818 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19820 return (PARSER_OK
);
19824 * parallel running threads
19829 BOOL WINAPI
sigHandler_default (DWORD sig
)
19833 case CTRL_CLOSE_EVENT
:
19836 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19837 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19838 * function otherwise it is too late (e.g. after returning from this function)
19843 SetConsoleCtrlHandler (NULL
, TRUE
);
19850 case CTRL_LOGOFF_EVENT
:
19851 case CTRL_SHUTDOWN_EVENT
:
19855 SetConsoleCtrlHandler (NULL
, TRUE
);
19863 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19867 case CTRL_CLOSE_EVENT
:
19871 SetConsoleCtrlHandler (NULL
, TRUE
);
19878 case CTRL_LOGOFF_EVENT
:
19879 case CTRL_SHUTDOWN_EVENT
:
19883 SetConsoleCtrlHandler (NULL
, TRUE
);
19891 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19893 if (callback
== NULL
)
19895 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19899 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19905 void sigHandler_default (int sig
)
19909 signal (sig
, NULL
);
19912 void sigHandler_benchmark (int sig
)
19916 signal (sig
, NULL
);
19919 void hc_signal (void (callback
) (int))
19921 if (callback
== NULL
) callback
= SIG_DFL
;
19923 signal (SIGINT
, callback
);
19924 signal (SIGTERM
, callback
);
19925 signal (SIGABRT
, callback
);
19930 void status_display ();
19932 void *thread_keypress (void *p
)
19934 int benchmark
= *((int *) p
);
19936 uint quiet
= data
.quiet
;
19940 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19942 int ch
= tty_getchar();
19944 if (ch
== -1) break;
19946 if (ch
== 0) continue;
19948 //https://github.com/hashcat/oclHashcat/issues/302
19953 hc_thread_mutex_lock (mux_display
);
19969 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19970 if (quiet
== 0) fflush (stdout
);
19982 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19983 if (quiet
== 0) fflush (stdout
);
19995 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19996 if (quiet
== 0) fflush (stdout
);
20008 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20009 if (quiet
== 0) fflush (stdout
);
20017 if (benchmark
== 1) break;
20019 stop_at_checkpoint ();
20023 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20024 if (quiet
== 0) fflush (stdout
);
20032 if (benchmark
== 1)
20044 //https://github.com/hashcat/oclHashcat/issues/302
20049 hc_thread_mutex_unlock (mux_display
);
20061 bool class_num (const u8 c
)
20063 return ((c
>= '0') && (c
<= '9'));
20066 bool class_lower (const u8 c
)
20068 return ((c
>= 'a') && (c
<= 'z'));
20071 bool class_upper (const u8 c
)
20073 return ((c
>= 'A') && (c
<= 'Z'));
20076 bool class_alpha (const u8 c
)
20078 return (class_lower (c
) || class_upper (c
));
20081 int conv_ctoi (const u8 c
)
20087 else if (class_upper (c
))
20089 return c
- 'A' + 10;
20095 int conv_itoc (const u8 c
)
20103 return c
+ 'A' - 10;
20113 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20114 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20115 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20116 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20117 #define MAX_KERNEL_RULES 255
20118 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20119 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20120 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20122 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20123 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20124 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20125 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20127 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20132 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20134 switch (rule_buf
[rule_pos
])
20140 case RULE_OP_MANGLE_NOOP
:
20141 SET_NAME (rule
, rule_buf
[rule_pos
]);
20144 case RULE_OP_MANGLE_LREST
:
20145 SET_NAME (rule
, rule_buf
[rule_pos
]);
20148 case RULE_OP_MANGLE_UREST
:
20149 SET_NAME (rule
, rule_buf
[rule_pos
]);
20152 case RULE_OP_MANGLE_LREST_UFIRST
:
20153 SET_NAME (rule
, rule_buf
[rule_pos
]);
20156 case RULE_OP_MANGLE_UREST_LFIRST
:
20157 SET_NAME (rule
, rule_buf
[rule_pos
]);
20160 case RULE_OP_MANGLE_TREST
:
20161 SET_NAME (rule
, rule_buf
[rule_pos
]);
20164 case RULE_OP_MANGLE_TOGGLE_AT
:
20165 SET_NAME (rule
, rule_buf
[rule_pos
]);
20166 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20169 case RULE_OP_MANGLE_REVERSE
:
20170 SET_NAME (rule
, rule_buf
[rule_pos
]);
20173 case RULE_OP_MANGLE_DUPEWORD
:
20174 SET_NAME (rule
, rule_buf
[rule_pos
]);
20177 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20178 SET_NAME (rule
, rule_buf
[rule_pos
]);
20179 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20182 case RULE_OP_MANGLE_REFLECT
:
20183 SET_NAME (rule
, rule_buf
[rule_pos
]);
20186 case RULE_OP_MANGLE_ROTATE_LEFT
:
20187 SET_NAME (rule
, rule_buf
[rule_pos
]);
20190 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20191 SET_NAME (rule
, rule_buf
[rule_pos
]);
20194 case RULE_OP_MANGLE_APPEND
:
20195 SET_NAME (rule
, rule_buf
[rule_pos
]);
20196 SET_P0 (rule
, rule_buf
[rule_pos
]);
20199 case RULE_OP_MANGLE_PREPEND
:
20200 SET_NAME (rule
, rule_buf
[rule_pos
]);
20201 SET_P0 (rule
, rule_buf
[rule_pos
]);
20204 case RULE_OP_MANGLE_DELETE_FIRST
:
20205 SET_NAME (rule
, rule_buf
[rule_pos
]);
20208 case RULE_OP_MANGLE_DELETE_LAST
:
20209 SET_NAME (rule
, rule_buf
[rule_pos
]);
20212 case RULE_OP_MANGLE_DELETE_AT
:
20213 SET_NAME (rule
, rule_buf
[rule_pos
]);
20214 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20217 case RULE_OP_MANGLE_EXTRACT
:
20218 SET_NAME (rule
, rule_buf
[rule_pos
]);
20219 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20220 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20223 case RULE_OP_MANGLE_OMIT
:
20224 SET_NAME (rule
, rule_buf
[rule_pos
]);
20225 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20226 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20229 case RULE_OP_MANGLE_INSERT
:
20230 SET_NAME (rule
, rule_buf
[rule_pos
]);
20231 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20232 SET_P1 (rule
, rule_buf
[rule_pos
]);
20235 case RULE_OP_MANGLE_OVERSTRIKE
:
20236 SET_NAME (rule
, rule_buf
[rule_pos
]);
20237 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20238 SET_P1 (rule
, rule_buf
[rule_pos
]);
20241 case RULE_OP_MANGLE_TRUNCATE_AT
:
20242 SET_NAME (rule
, rule_buf
[rule_pos
]);
20243 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20246 case RULE_OP_MANGLE_REPLACE
:
20247 SET_NAME (rule
, rule_buf
[rule_pos
]);
20248 SET_P0 (rule
, rule_buf
[rule_pos
]);
20249 SET_P1 (rule
, rule_buf
[rule_pos
]);
20252 case RULE_OP_MANGLE_PURGECHAR
:
20256 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20260 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20261 SET_NAME (rule
, rule_buf
[rule_pos
]);
20262 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20265 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20266 SET_NAME (rule
, rule_buf
[rule_pos
]);
20267 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20270 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20271 SET_NAME (rule
, rule_buf
[rule_pos
]);
20274 case RULE_OP_MANGLE_SWITCH_FIRST
:
20275 SET_NAME (rule
, rule_buf
[rule_pos
]);
20278 case RULE_OP_MANGLE_SWITCH_LAST
:
20279 SET_NAME (rule
, rule_buf
[rule_pos
]);
20282 case RULE_OP_MANGLE_SWITCH_AT
:
20283 SET_NAME (rule
, rule_buf
[rule_pos
]);
20284 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20285 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20288 case RULE_OP_MANGLE_CHR_SHIFTL
:
20289 SET_NAME (rule
, rule_buf
[rule_pos
]);
20290 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20293 case RULE_OP_MANGLE_CHR_SHIFTR
:
20294 SET_NAME (rule
, rule_buf
[rule_pos
]);
20295 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20298 case RULE_OP_MANGLE_CHR_INCR
:
20299 SET_NAME (rule
, rule_buf
[rule_pos
]);
20300 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20303 case RULE_OP_MANGLE_CHR_DECR
:
20304 SET_NAME (rule
, rule_buf
[rule_pos
]);
20305 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20308 case RULE_OP_MANGLE_REPLACE_NP1
:
20309 SET_NAME (rule
, rule_buf
[rule_pos
]);
20310 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20313 case RULE_OP_MANGLE_REPLACE_NM1
:
20314 SET_NAME (rule
, rule_buf
[rule_pos
]);
20315 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20318 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20319 SET_NAME (rule
, rule_buf
[rule_pos
]);
20320 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20323 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20324 SET_NAME (rule
, rule_buf
[rule_pos
]);
20325 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20328 case RULE_OP_MANGLE_TITLE
:
20329 SET_NAME (rule
, rule_buf
[rule_pos
]);
20338 if (rule_pos
< rule_len
) return (-1);
20343 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20347 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20351 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20355 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20359 case RULE_OP_MANGLE_NOOP
:
20360 rule_buf
[rule_pos
] = rule_cmd
;
20363 case RULE_OP_MANGLE_LREST
:
20364 rule_buf
[rule_pos
] = rule_cmd
;
20367 case RULE_OP_MANGLE_UREST
:
20368 rule_buf
[rule_pos
] = rule_cmd
;
20371 case RULE_OP_MANGLE_LREST_UFIRST
:
20372 rule_buf
[rule_pos
] = rule_cmd
;
20375 case RULE_OP_MANGLE_UREST_LFIRST
:
20376 rule_buf
[rule_pos
] = rule_cmd
;
20379 case RULE_OP_MANGLE_TREST
:
20380 rule_buf
[rule_pos
] = rule_cmd
;
20383 case RULE_OP_MANGLE_TOGGLE_AT
:
20384 rule_buf
[rule_pos
] = rule_cmd
;
20385 GET_P0_CONV (rule
);
20388 case RULE_OP_MANGLE_REVERSE
:
20389 rule_buf
[rule_pos
] = rule_cmd
;
20392 case RULE_OP_MANGLE_DUPEWORD
:
20393 rule_buf
[rule_pos
] = rule_cmd
;
20396 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20397 rule_buf
[rule_pos
] = rule_cmd
;
20398 GET_P0_CONV (rule
);
20401 case RULE_OP_MANGLE_REFLECT
:
20402 rule_buf
[rule_pos
] = rule_cmd
;
20405 case RULE_OP_MANGLE_ROTATE_LEFT
:
20406 rule_buf
[rule_pos
] = rule_cmd
;
20409 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20410 rule_buf
[rule_pos
] = rule_cmd
;
20413 case RULE_OP_MANGLE_APPEND
:
20414 rule_buf
[rule_pos
] = rule_cmd
;
20418 case RULE_OP_MANGLE_PREPEND
:
20419 rule_buf
[rule_pos
] = rule_cmd
;
20423 case RULE_OP_MANGLE_DELETE_FIRST
:
20424 rule_buf
[rule_pos
] = rule_cmd
;
20427 case RULE_OP_MANGLE_DELETE_LAST
:
20428 rule_buf
[rule_pos
] = rule_cmd
;
20431 case RULE_OP_MANGLE_DELETE_AT
:
20432 rule_buf
[rule_pos
] = rule_cmd
;
20433 GET_P0_CONV (rule
);
20436 case RULE_OP_MANGLE_EXTRACT
:
20437 rule_buf
[rule_pos
] = rule_cmd
;
20438 GET_P0_CONV (rule
);
20439 GET_P1_CONV (rule
);
20442 case RULE_OP_MANGLE_OMIT
:
20443 rule_buf
[rule_pos
] = rule_cmd
;
20444 GET_P0_CONV (rule
);
20445 GET_P1_CONV (rule
);
20448 case RULE_OP_MANGLE_INSERT
:
20449 rule_buf
[rule_pos
] = rule_cmd
;
20450 GET_P0_CONV (rule
);
20454 case RULE_OP_MANGLE_OVERSTRIKE
:
20455 rule_buf
[rule_pos
] = rule_cmd
;
20456 GET_P0_CONV (rule
);
20460 case RULE_OP_MANGLE_TRUNCATE_AT
:
20461 rule_buf
[rule_pos
] = rule_cmd
;
20462 GET_P0_CONV (rule
);
20465 case RULE_OP_MANGLE_REPLACE
:
20466 rule_buf
[rule_pos
] = rule_cmd
;
20471 case RULE_OP_MANGLE_PURGECHAR
:
20475 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20479 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20480 rule_buf
[rule_pos
] = rule_cmd
;
20481 GET_P0_CONV (rule
);
20484 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20485 rule_buf
[rule_pos
] = rule_cmd
;
20486 GET_P0_CONV (rule
);
20489 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20490 rule_buf
[rule_pos
] = rule_cmd
;
20493 case RULE_OP_MANGLE_SWITCH_FIRST
:
20494 rule_buf
[rule_pos
] = rule_cmd
;
20497 case RULE_OP_MANGLE_SWITCH_LAST
:
20498 rule_buf
[rule_pos
] = rule_cmd
;
20501 case RULE_OP_MANGLE_SWITCH_AT
:
20502 rule_buf
[rule_pos
] = rule_cmd
;
20503 GET_P0_CONV (rule
);
20504 GET_P1_CONV (rule
);
20507 case RULE_OP_MANGLE_CHR_SHIFTL
:
20508 rule_buf
[rule_pos
] = rule_cmd
;
20509 GET_P0_CONV (rule
);
20512 case RULE_OP_MANGLE_CHR_SHIFTR
:
20513 rule_buf
[rule_pos
] = rule_cmd
;
20514 GET_P0_CONV (rule
);
20517 case RULE_OP_MANGLE_CHR_INCR
:
20518 rule_buf
[rule_pos
] = rule_cmd
;
20519 GET_P0_CONV (rule
);
20522 case RULE_OP_MANGLE_CHR_DECR
:
20523 rule_buf
[rule_pos
] = rule_cmd
;
20524 GET_P0_CONV (rule
);
20527 case RULE_OP_MANGLE_REPLACE_NP1
:
20528 rule_buf
[rule_pos
] = rule_cmd
;
20529 GET_P0_CONV (rule
);
20532 case RULE_OP_MANGLE_REPLACE_NM1
:
20533 rule_buf
[rule_pos
] = rule_cmd
;
20534 GET_P0_CONV (rule
);
20537 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20538 rule_buf
[rule_pos
] = rule_cmd
;
20539 GET_P0_CONV (rule
);
20542 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20543 rule_buf
[rule_pos
] = rule_cmd
;
20544 GET_P0_CONV (rule
);
20547 case RULE_OP_MANGLE_TITLE
:
20548 rule_buf
[rule_pos
] = rule_cmd
;
20552 return rule_pos
- 1;
20570 * CPU rules : this is from hashcat sources, cpu based rules
20573 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20574 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20576 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20577 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20578 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20580 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20581 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20582 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20584 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20588 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20593 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20597 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20602 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20606 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20611 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20616 for (l
= 0; l
< arr_len
; l
++)
20618 r
= arr_len
- 1 - l
;
20622 MANGLE_SWITCH (arr
, l
, r
);
20628 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20630 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20632 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20634 return (arr_len
* 2);
20637 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20639 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20641 int orig_len
= arr_len
;
20645 for (i
= 0; i
< times
; i
++)
20647 memcpy (&arr
[arr_len
], arr
, orig_len
);
20649 arr_len
+= orig_len
;
20655 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20657 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20659 mangle_double (arr
, arr_len
);
20661 mangle_reverse (arr
+ arr_len
, arr_len
);
20663 return (arr_len
* 2);
20666 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20671 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20673 MANGLE_SWITCH (arr
, l
, r
);
20679 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20684 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20686 MANGLE_SWITCH (arr
, l
, r
);
20692 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20694 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20698 return (arr_len
+ 1);
20701 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20703 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20707 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20709 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20714 return (arr_len
+ 1);
20717 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20719 if (upos
>= arr_len
) return (arr_len
);
20723 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20725 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20728 return (arr_len
- 1);
20731 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20733 if (upos
>= arr_len
) return (arr_len
);
20735 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20739 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20741 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20747 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20749 if (upos
>= arr_len
) return (arr_len
);
20751 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20755 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20757 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20760 return (arr_len
- ulen
);
20763 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20765 if (upos
>= arr_len
) return (arr_len
);
20767 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20771 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20773 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20778 return (arr_len
+ 1);
20781 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
)
20783 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20785 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20787 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20789 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20791 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20793 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20795 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20797 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20799 return (arr_len
+ arr2_cpy
);
20802 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20804 if (upos
>= arr_len
) return (arr_len
);
20811 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20813 if (upos
>= arr_len
) return (arr_len
);
20815 memset (arr
+ upos
, 0, arr_len
- upos
);
20820 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20824 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20826 if (arr
[arr_pos
] != oldc
) continue;
20828 arr
[arr_pos
] = newc
;
20834 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20840 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20842 if (arr
[arr_pos
] == c
) continue;
20844 arr
[ret_len
] = arr
[arr_pos
];
20852 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20854 if (ulen
> arr_len
) return (arr_len
);
20856 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20858 char cs
[100] = { 0 };
20860 memcpy (cs
, arr
, ulen
);
20864 for (i
= 0; i
< ulen
; i
++)
20868 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20874 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20876 if (ulen
> arr_len
) return (arr_len
);
20878 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20880 int upos
= arr_len
- ulen
;
20884 for (i
= 0; i
< ulen
; i
++)
20886 char c
= arr
[upos
+ i
];
20888 arr_len
= mangle_append (arr
, arr_len
, c
);
20894 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20896 if ( arr_len
== 0) return (arr_len
);
20897 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20899 char c
= arr
[upos
];
20903 for (i
= 0; i
< ulen
; i
++)
20905 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20911 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20913 if ( arr_len
== 0) return (arr_len
);
20914 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20918 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20920 int new_pos
= arr_pos
* 2;
20922 arr
[new_pos
] = arr
[arr_pos
];
20924 arr
[new_pos
+ 1] = arr
[arr_pos
];
20927 return (arr_len
* 2);
20930 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20932 if (upos
>= arr_len
) return (arr_len
);
20933 if (upos2
>= arr_len
) return (arr_len
);
20935 MANGLE_SWITCH (arr
, upos
, upos2
);
20940 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20942 MANGLE_SWITCH (arr
, upos
, upos2
);
20947 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20949 if (upos
>= arr_len
) return (arr_len
);
20956 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20958 if (upos
>= arr_len
) return (arr_len
);
20965 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20967 if (upos
>= arr_len
) return (arr_len
);
20974 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20976 if (upos
>= arr_len
) return (arr_len
);
20983 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20985 int upper_next
= 1;
20989 for (pos
= 0; pos
< arr_len
; pos
++)
20991 if (arr
[pos
] == ' ')
21002 MANGLE_UPPER_AT (arr
, pos
);
21006 MANGLE_LOWER_AT (arr
, pos
);
21013 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21015 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21021 for (j
= 0; j
< rp_gen_num
; j
++)
21028 switch ((char) get_random_num (0, 9))
21031 r
= get_random_num (0, sizeof (grp_op_nop
));
21032 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21036 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21037 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21038 p1
= get_random_num (0, sizeof (grp_pos
));
21039 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21043 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21044 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21045 p1
= get_random_num (1, 6);
21046 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21050 r
= get_random_num (0, sizeof (grp_op_chr
));
21051 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21052 p1
= get_random_num (0x20, 0x7e);
21053 rule_buf
[rule_pos
++] = (char) p1
;
21057 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21058 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21059 p1
= get_random_num (0x20, 0x7e);
21060 rule_buf
[rule_pos
++] = (char) p1
;
21061 p2
= get_random_num (0x20, 0x7e);
21063 p2
= get_random_num (0x20, 0x7e);
21064 rule_buf
[rule_pos
++] = (char) p2
;
21068 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21069 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21070 p1
= get_random_num (0, sizeof (grp_pos
));
21071 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21072 p2
= get_random_num (0x20, 0x7e);
21073 rule_buf
[rule_pos
++] = (char) p2
;
21077 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21078 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21079 p1
= get_random_num (0, sizeof (grp_pos
));
21080 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21081 p2
= get_random_num (0, sizeof (grp_pos
));
21083 p2
= get_random_num (0, sizeof (grp_pos
));
21084 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21088 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21089 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21090 p1
= get_random_num (0, sizeof (grp_pos
));
21091 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21092 p2
= get_random_num (1, sizeof (grp_pos
));
21094 p2
= get_random_num (1, sizeof (grp_pos
));
21095 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21099 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21100 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21101 p1
= get_random_num (0, sizeof (grp_pos
));
21102 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21103 p2
= get_random_num (1, sizeof (grp_pos
));
21104 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21105 p3
= get_random_num (0, sizeof (grp_pos
));
21106 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21114 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21116 char mem
[BLOCK_SIZE
] = { 0 };
21118 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21120 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21122 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21124 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21126 int out_len
= in_len
;
21127 int mem_len
= in_len
;
21129 memcpy (out
, in
, out_len
);
21133 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21138 switch (rule
[rule_pos
])
21143 case RULE_OP_MANGLE_NOOP
:
21146 case RULE_OP_MANGLE_LREST
:
21147 out_len
= mangle_lrest (out
, out_len
);
21150 case RULE_OP_MANGLE_UREST
:
21151 out_len
= mangle_urest (out
, out_len
);
21154 case RULE_OP_MANGLE_LREST_UFIRST
:
21155 out_len
= mangle_lrest (out
, out_len
);
21156 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21159 case RULE_OP_MANGLE_UREST_LFIRST
:
21160 out_len
= mangle_urest (out
, out_len
);
21161 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21164 case RULE_OP_MANGLE_TREST
:
21165 out_len
= mangle_trest (out
, out_len
);
21168 case RULE_OP_MANGLE_TOGGLE_AT
:
21169 NEXT_RULEPOS (rule_pos
);
21170 NEXT_RPTOI (rule
, rule_pos
, upos
);
21171 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21174 case RULE_OP_MANGLE_REVERSE
:
21175 out_len
= mangle_reverse (out
, out_len
);
21178 case RULE_OP_MANGLE_DUPEWORD
:
21179 out_len
= mangle_double (out
, out_len
);
21182 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21183 NEXT_RULEPOS (rule_pos
);
21184 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21185 out_len
= mangle_double_times (out
, out_len
, ulen
);
21188 case RULE_OP_MANGLE_REFLECT
:
21189 out_len
= mangle_reflect (out
, out_len
);
21192 case RULE_OP_MANGLE_ROTATE_LEFT
:
21193 mangle_rotate_left (out
, out_len
);
21196 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21197 mangle_rotate_right (out
, out_len
);
21200 case RULE_OP_MANGLE_APPEND
:
21201 NEXT_RULEPOS (rule_pos
);
21202 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21205 case RULE_OP_MANGLE_PREPEND
:
21206 NEXT_RULEPOS (rule_pos
);
21207 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21210 case RULE_OP_MANGLE_DELETE_FIRST
:
21211 out_len
= mangle_delete_at (out
, out_len
, 0);
21214 case RULE_OP_MANGLE_DELETE_LAST
:
21215 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21218 case RULE_OP_MANGLE_DELETE_AT
:
21219 NEXT_RULEPOS (rule_pos
);
21220 NEXT_RPTOI (rule
, rule_pos
, upos
);
21221 out_len
= mangle_delete_at (out
, out_len
, upos
);
21224 case RULE_OP_MANGLE_EXTRACT
:
21225 NEXT_RULEPOS (rule_pos
);
21226 NEXT_RPTOI (rule
, rule_pos
, upos
);
21227 NEXT_RULEPOS (rule_pos
);
21228 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21229 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21232 case RULE_OP_MANGLE_OMIT
:
21233 NEXT_RULEPOS (rule_pos
);
21234 NEXT_RPTOI (rule
, rule_pos
, upos
);
21235 NEXT_RULEPOS (rule_pos
);
21236 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21237 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21240 case RULE_OP_MANGLE_INSERT
:
21241 NEXT_RULEPOS (rule_pos
);
21242 NEXT_RPTOI (rule
, rule_pos
, upos
);
21243 NEXT_RULEPOS (rule_pos
);
21244 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21247 case RULE_OP_MANGLE_OVERSTRIKE
:
21248 NEXT_RULEPOS (rule_pos
);
21249 NEXT_RPTOI (rule
, rule_pos
, upos
);
21250 NEXT_RULEPOS (rule_pos
);
21251 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21254 case RULE_OP_MANGLE_TRUNCATE_AT
:
21255 NEXT_RULEPOS (rule_pos
);
21256 NEXT_RPTOI (rule
, rule_pos
, upos
);
21257 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21260 case RULE_OP_MANGLE_REPLACE
:
21261 NEXT_RULEPOS (rule_pos
);
21262 NEXT_RULEPOS (rule_pos
);
21263 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21266 case RULE_OP_MANGLE_PURGECHAR
:
21267 NEXT_RULEPOS (rule_pos
);
21268 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21271 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21275 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21276 NEXT_RULEPOS (rule_pos
);
21277 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21278 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21281 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21282 NEXT_RULEPOS (rule_pos
);
21283 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21284 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21287 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21288 out_len
= mangle_dupechar (out
, out_len
);
21291 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21292 NEXT_RULEPOS (rule_pos
);
21293 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21294 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21297 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21298 NEXT_RULEPOS (rule_pos
);
21299 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21300 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21303 case RULE_OP_MANGLE_SWITCH_FIRST
:
21304 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21307 case RULE_OP_MANGLE_SWITCH_LAST
:
21308 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21311 case RULE_OP_MANGLE_SWITCH_AT
:
21312 NEXT_RULEPOS (rule_pos
);
21313 NEXT_RPTOI (rule
, rule_pos
, upos
);
21314 NEXT_RULEPOS (rule_pos
);
21315 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21316 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21319 case RULE_OP_MANGLE_CHR_SHIFTL
:
21320 NEXT_RULEPOS (rule_pos
);
21321 NEXT_RPTOI (rule
, rule_pos
, upos
);
21322 mangle_chr_shiftl (out
, out_len
, upos
);
21325 case RULE_OP_MANGLE_CHR_SHIFTR
:
21326 NEXT_RULEPOS (rule_pos
);
21327 NEXT_RPTOI (rule
, rule_pos
, upos
);
21328 mangle_chr_shiftr (out
, out_len
, upos
);
21331 case RULE_OP_MANGLE_CHR_INCR
:
21332 NEXT_RULEPOS (rule_pos
);
21333 NEXT_RPTOI (rule
, rule_pos
, upos
);
21334 mangle_chr_incr (out
, out_len
, upos
);
21337 case RULE_OP_MANGLE_CHR_DECR
:
21338 NEXT_RULEPOS (rule_pos
);
21339 NEXT_RPTOI (rule
, rule_pos
, upos
);
21340 mangle_chr_decr (out
, out_len
, upos
);
21343 case RULE_OP_MANGLE_REPLACE_NP1
:
21344 NEXT_RULEPOS (rule_pos
);
21345 NEXT_RPTOI (rule
, rule_pos
, upos
);
21346 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21349 case RULE_OP_MANGLE_REPLACE_NM1
:
21350 NEXT_RULEPOS (rule_pos
);
21351 NEXT_RPTOI (rule
, rule_pos
, upos
);
21352 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21355 case RULE_OP_MANGLE_TITLE
:
21356 out_len
= mangle_title (out
, out_len
);
21359 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21360 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21361 NEXT_RULEPOS (rule_pos
);
21362 NEXT_RPTOI (rule
, rule_pos
, upos
);
21363 NEXT_RULEPOS (rule_pos
);
21364 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21365 NEXT_RULEPOS (rule_pos
);
21366 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21367 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21370 case RULE_OP_MANGLE_APPEND_MEMORY
:
21371 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21372 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21373 memcpy (out
+ out_len
, mem
, mem_len
);
21374 out_len
+= mem_len
;
21377 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21378 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21379 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21380 memcpy (mem
+ mem_len
, out
, out_len
);
21381 out_len
+= mem_len
;
21382 memcpy (out
, mem
, out_len
);
21385 case RULE_OP_MEMORIZE_WORD
:
21386 memcpy (mem
, out
, out_len
);
21390 case RULE_OP_REJECT_LESS
:
21391 NEXT_RULEPOS (rule_pos
);
21392 NEXT_RPTOI (rule
, rule_pos
, upos
);
21393 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21396 case RULE_OP_REJECT_GREATER
:
21397 NEXT_RULEPOS (rule_pos
);
21398 NEXT_RPTOI (rule
, rule_pos
, upos
);
21399 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21402 case RULE_OP_REJECT_CONTAIN
:
21403 NEXT_RULEPOS (rule_pos
);
21404 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21407 case RULE_OP_REJECT_NOT_CONTAIN
:
21408 NEXT_RULEPOS (rule_pos
);
21409 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21412 case RULE_OP_REJECT_EQUAL_FIRST
:
21413 NEXT_RULEPOS (rule_pos
);
21414 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21417 case RULE_OP_REJECT_EQUAL_LAST
:
21418 NEXT_RULEPOS (rule_pos
);
21419 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21422 case RULE_OP_REJECT_EQUAL_AT
:
21423 NEXT_RULEPOS (rule_pos
);
21424 NEXT_RPTOI (rule
, rule_pos
, upos
);
21425 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21426 NEXT_RULEPOS (rule_pos
);
21427 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21430 case RULE_OP_REJECT_CONTAINS
:
21431 NEXT_RULEPOS (rule_pos
);
21432 NEXT_RPTOI (rule
, rule_pos
, upos
);
21433 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21434 NEXT_RULEPOS (rule_pos
);
21435 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21436 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21439 case RULE_OP_REJECT_MEMORY
:
21440 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21444 return (RULE_RC_SYNTAX_ERROR
);
21449 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);