2 * Author......: Jens Steube <jens.steube@gmail.com>
9 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
10 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
16 #define GET_ACCEL(x) GPU_ACCEL_AMD_ ## x
17 #define GET_LOOPS(x) GPU_LOOPS_AMD_ ## x
23 uint32_t rotl32 (const uint32_t a
, const uint n
)
25 return ((a
<< n
) | (a
>> (32 - n
)));
28 uint32_t rotr32 (const uint32_t a
, const uint n
)
30 return ((a
>> n
) | (a
<< (32 - n
)));
33 uint64_t rotl64 (const uint64_t a
, const uint n
)
35 return ((a
<< n
) | (a
>> (64 - n
)));
38 uint64_t rotr64 (const uint64_t a
, const uint n
)
40 return ((a
>> n
) | (a
<< (64 - n
)));
44 * ciphers for use on cpu
51 * hashes for use on cpu
55 #include "cpu-sha256.c"
63 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
69 for (int i
= 0; i
< last_len
; i
++)
79 int max_len
= (int) sizeof (s
);
81 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
83 if (len
> max_len
) len
= max_len
;
85 fwrite (s
, len
, 1, fp
);
92 void log_out_nn (FILE *fp
, const char *fmt
, ...)
94 if (SUPPRESS_OUTPUT
) return;
100 log_final (fp
, fmt
, ap
);
105 void log_info_nn (const char *fmt
, ...)
107 if (SUPPRESS_OUTPUT
) return;
113 log_final (stdout
, fmt
, ap
);
118 void log_error_nn (const char *fmt
, ...)
120 if (SUPPRESS_OUTPUT
) return;
126 log_final (stderr
, fmt
, ap
);
131 void log_out (FILE *fp
, const char *fmt
, ...)
133 if (SUPPRESS_OUTPUT
) return;
139 log_final (fp
, fmt
, ap
);
148 void log_info (const char *fmt
, ...)
150 if (SUPPRESS_OUTPUT
) return;
156 log_final (stdout
, fmt
, ap
);
160 fputc ('\n', stdout
);
165 void log_error (const char *fmt
, ...)
167 if (SUPPRESS_OUTPUT
) return;
169 fputc ('\n', stderr
);
170 fputc ('\n', stderr
);
176 log_final (stderr
, fmt
, ap
);
180 fputc ('\n', stderr
);
181 fputc ('\n', stderr
);
190 uint
byte_swap_32 (const uint n
)
192 return (n
& 0xff000000) >> 24
193 | (n
& 0x00ff0000) >> 8
194 | (n
& 0x0000ff00) << 8
195 | (n
& 0x000000ff) << 24;
198 uint64_t byte_swap_64 (const uint64_t n
)
200 return (n
& 0xff00000000000000ULL
) >> 56
201 | (n
& 0x00ff000000000000ULL
) >> 40
202 | (n
& 0x0000ff0000000000ULL
) >> 24
203 | (n
& 0x000000ff00000000ULL
) >> 8
204 | (n
& 0x00000000ff000000ULL
) << 8
205 | (n
& 0x0000000000ff0000ULL
) << 24
206 | (n
& 0x000000000000ff00ULL
) << 40
207 | (n
& 0x00000000000000ffULL
) << 56;
210 char int_to_base32 (const char c
)
212 static const char tbl
[0x20] =
214 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
215 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
218 return tbl
[(const uint8_t) c
];
221 char base32_to_int (const char c
)
223 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
224 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
229 char int_to_itoa32 (const char c
)
231 static const char tbl
[0x20] =
233 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
234 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
237 return tbl
[(const uint8_t) c
];
240 char itoa32_to_int (const char c
)
242 if ((c
>= '0') && (c
<= '9')) return c
- '0';
243 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
248 char int_to_itoa64 (const char c
)
250 static const char tbl
[0x40] =
252 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
253 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
254 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
255 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
258 return tbl
[(const uint8_t) c
];
261 char itoa64_to_int (const char c
)
263 static const char tbl
[0x100] =
265 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
266 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
267 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
268 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
269 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
270 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
271 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
272 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
273 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
274 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
275 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
276 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
277 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
278 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
279 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
280 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 return tbl
[(const uint8_t) c
];
286 char int_to_base64 (const char c
)
288 static const char tbl
[0x40] =
290 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
291 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
292 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
293 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
296 return tbl
[(const uint8_t) c
];
299 char base64_to_int (const char c
)
301 static const char tbl
[0x100] =
303 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
306 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
308 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
310 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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,
321 return tbl
[(const uint8_t) c
];
324 char int_to_bf64 (const char c
)
326 static const char tbl
[0x40] =
328 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
329 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
330 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
331 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
334 return tbl
[(const uint8_t) c
];
337 char bf64_to_int (const char c
)
339 static const char tbl
[0x100] =
341 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
344 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
346 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
348 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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,
359 return tbl
[(const uint8_t) c
];
362 char int_to_lotus64 (const char c
)
364 if (c
< 10) return '0' + c
;
365 else if (c
< 36) return 'A' + c
- 10;
366 else if (c
< 62) return 'a' + c
- 36;
367 else if (c
== 62) return '+';
368 else if (c
== 63) return '/';
373 char lotus64_to_int (const char c
)
375 if ((c
>= '0') && (c
<= '9')) return c
- '0';
376 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
377 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
378 else if (c
== '+') return 62;
379 else if (c
== '/') return 63;
385 int base32_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
387 char *in_ptr
= in_buf
;
389 char *out_ptr
= out_buf
;
391 for (int i
= 0; i
< in_len
; i
+= 8)
393 char out_val0
= f (in_ptr
[0] & 0x7f);
394 char out_val1
= f (in_ptr
[1] & 0x7f);
395 char out_val2
= f (in_ptr
[2] & 0x7f);
396 char out_val3
= f (in_ptr
[3] & 0x7f);
397 char out_val4
= f (in_ptr
[4] & 0x7f);
398 char out_val5
= f (in_ptr
[5] & 0x7f);
399 char out_val6
= f (in_ptr
[6] & 0x7f);
400 char out_val7
= f (in_ptr
[7] & 0x7f);
402 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
403 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
404 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
405 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
406 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
412 for (int i
= 0; i
< in_len
; i
++)
414 if (in_buf
[i
] != '=') continue;
419 int out_len
= (in_len
* 5) / 8;
424 int base32_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
426 char *in_ptr
= in_buf
;
428 char *out_ptr
= out_buf
;
430 for (int i
= 0; i
< in_len
; i
+= 5)
432 char out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
433 char out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
434 char out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
435 char out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
436 char out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
437 char out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
438 char out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
439 char out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
441 out_ptr
[0] = out_val0
& 0x7f;
442 out_ptr
[1] = out_val1
& 0x7f;
443 out_ptr
[2] = out_val2
& 0x7f;
444 out_ptr
[3] = out_val3
& 0x7f;
445 out_ptr
[4] = out_val4
& 0x7f;
446 out_ptr
[5] = out_val5
& 0x7f;
447 out_ptr
[6] = out_val6
& 0x7f;
448 out_ptr
[7] = out_val7
& 0x7f;
454 int out_len
= (in_len
* 8) / 5;
456 for (int i
= 0; i
< (7 - (in_len
% 7)); i
++)
460 out_buf
[out_len
] = '=';
466 int base64_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
468 char *in_ptr
= in_buf
;
470 char *out_ptr
= out_buf
;
472 for (int i
= 0; i
< in_len
; i
+= 4)
474 char out_val0
= f (in_ptr
[0] & 0x7f);
475 char out_val1
= f (in_ptr
[1] & 0x7f);
476 char out_val2
= f (in_ptr
[2] & 0x7f);
477 char out_val3
= f (in_ptr
[3] & 0x7f);
479 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
480 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
481 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
487 for (int i
= 0; i
< in_len
; i
++)
489 if (in_buf
[i
] != '=') continue;
494 int out_len
= (in_len
* 6) / 8;
499 int base64_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
501 char *in_ptr
= in_buf
;
503 char *out_ptr
= out_buf
;
505 for (int i
= 0; i
< in_len
; i
+= 3)
507 char out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
508 char out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
509 char out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
510 char out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
512 out_ptr
[0] = out_val0
& 0x7f;
513 out_ptr
[1] = out_val1
& 0x7f;
514 out_ptr
[2] = out_val2
& 0x7f;
515 out_ptr
[3] = out_val3
& 0x7f;
521 int out_len
= (in_len
* 8) / 6;
523 for (int i
= 0; i
< (3 - (in_len
% 3)); i
++)
527 out_buf
[out_len
] = '=';
533 static void AES128_decrypt_cbc (const uint key
[4], const uint iv
[4], const uint in
[16], uint out
[16])
537 AES_set_decrypt_key ((unsigned char *) key
, 128, &skey
);
546 for (int i
= 0; i
< 16; i
+= 4)
556 AES_decrypt (&skey
, (char *) _in
, (char *) _out
);
563 out
[i
+ 0] = _out
[0];
564 out
[i
+ 1] = _out
[1];
565 out
[i
+ 2] = _out
[2];
566 out
[i
+ 3] = _out
[3];
575 static void juniper_decrypt_hash (char *in
, char *out
)
579 char base64_buf
[100];
581 memset (base64_buf
, 0, sizeof (base64_buf
));
583 base64_decode (base64_to_int
, in
, DISPLAY_LEN_MIN_501
, base64_buf
);
587 uint juniper_iv
[4] = { 0 };
589 memcpy (juniper_iv
, base64_buf
, 12);
591 memcpy (out
, juniper_iv
, 12);
597 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
598 juniper_key
[1] = byte_swap_32 (0x8df91059);
599 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
600 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
604 uint
*in_ptr
= (uint
*) (base64_buf
+ 12);
605 uint
*out_ptr
= (uint
*) (out
+ 12);
607 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
610 uint
is_valid_hex_char (const char c
)
612 if ((c
>= '0') && (c
<= '9')) return 1;
613 if ((c
>= 'A') && (c
<= 'F')) return 1;
614 if ((c
>= 'a') && (c
<= 'f')) return 1;
619 char hex_convert (const char c
)
621 return (c
& 15) + (c
>> 6) * 9;
624 char hex_to_char (const char hex
[2])
628 v
|= (hex_convert (hex
[1]) << 0);
629 v
|= (hex_convert (hex
[0]) << 4);
634 uint
hex_to_uint (const char hex
[8])
638 v
|= hex_convert (hex
[7]) << 0;
639 v
|= hex_convert (hex
[6]) << 4;
640 v
|= hex_convert (hex
[5]) << 8;
641 v
|= hex_convert (hex
[4]) << 12;
642 v
|= hex_convert (hex
[3]) << 16;
643 v
|= hex_convert (hex
[2]) << 20;
644 v
|= hex_convert (hex
[1]) << 24;
645 v
|= hex_convert (hex
[0]) << 28;
650 uint64_t hex_to_uint64_t (const char hex
[16])
654 v
|= ((uint64_t) hex_convert (hex
[15]) << 0);
655 v
|= ((uint64_t) hex_convert (hex
[14]) << 4);
656 v
|= ((uint64_t) hex_convert (hex
[13]) << 8);
657 v
|= ((uint64_t) hex_convert (hex
[12]) << 12);
658 v
|= ((uint64_t) hex_convert (hex
[11]) << 16);
659 v
|= ((uint64_t) hex_convert (hex
[10]) << 20);
660 v
|= ((uint64_t) hex_convert (hex
[ 9]) << 24);
661 v
|= ((uint64_t) hex_convert (hex
[ 8]) << 28);
662 v
|= ((uint64_t) hex_convert (hex
[ 7]) << 32);
663 v
|= ((uint64_t) hex_convert (hex
[ 6]) << 36);
664 v
|= ((uint64_t) hex_convert (hex
[ 5]) << 40);
665 v
|= ((uint64_t) hex_convert (hex
[ 4]) << 44);
666 v
|= ((uint64_t) hex_convert (hex
[ 3]) << 48);
667 v
|= ((uint64_t) hex_convert (hex
[ 2]) << 52);
668 v
|= ((uint64_t) hex_convert (hex
[ 1]) << 56);
669 v
|= ((uint64_t) hex_convert (hex
[ 0]) << 60);
674 void bin_to_hex_lower (uint v
, char hex
[8])
676 hex
[0] = v
>> 28 & 15;
677 hex
[1] = v
>> 24 & 15;
678 hex
[2] = v
>> 20 & 15;
679 hex
[3] = v
>> 16 & 15;
680 hex
[4] = v
>> 12 & 15;
681 hex
[5] = v
>> 8 & 15;
682 hex
[6] = v
>> 4 & 15;
683 hex
[7] = v
>> 0 & 15;
687 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
688 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
689 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
690 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
691 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
692 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
693 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
694 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
697 void phpass_decode (unsigned char digest
[16], unsigned char buf
[22])
701 l
= itoa64_to_int (buf
[ 0]) << 0;
702 l
|= itoa64_to_int (buf
[ 1]) << 6;
703 l
|= itoa64_to_int (buf
[ 2]) << 12;
704 l
|= itoa64_to_int (buf
[ 3]) << 18;
706 digest
[ 0] = (l
>> 0) & 0xff;
707 digest
[ 1] = (l
>> 8) & 0xff;
708 digest
[ 2] = (l
>> 16) & 0xff;
710 l
= itoa64_to_int (buf
[ 4]) << 0;
711 l
|= itoa64_to_int (buf
[ 5]) << 6;
712 l
|= itoa64_to_int (buf
[ 6]) << 12;
713 l
|= itoa64_to_int (buf
[ 7]) << 18;
715 digest
[ 3] = (l
>> 0) & 0xff;
716 digest
[ 4] = (l
>> 8) & 0xff;
717 digest
[ 5] = (l
>> 16) & 0xff;
719 l
= itoa64_to_int (buf
[ 8]) << 0;
720 l
|= itoa64_to_int (buf
[ 9]) << 6;
721 l
|= itoa64_to_int (buf
[10]) << 12;
722 l
|= itoa64_to_int (buf
[11]) << 18;
724 digest
[ 6] = (l
>> 0) & 0xff;
725 digest
[ 7] = (l
>> 8) & 0xff;
726 digest
[ 8] = (l
>> 16) & 0xff;
728 l
= itoa64_to_int (buf
[12]) << 0;
729 l
|= itoa64_to_int (buf
[13]) << 6;
730 l
|= itoa64_to_int (buf
[14]) << 12;
731 l
|= itoa64_to_int (buf
[15]) << 18;
733 digest
[ 9] = (l
>> 0) & 0xff;
734 digest
[10] = (l
>> 8) & 0xff;
735 digest
[11] = (l
>> 16) & 0xff;
737 l
= itoa64_to_int (buf
[16]) << 0;
738 l
|= itoa64_to_int (buf
[17]) << 6;
739 l
|= itoa64_to_int (buf
[18]) << 12;
740 l
|= itoa64_to_int (buf
[19]) << 18;
742 digest
[12] = (l
>> 0) & 0xff;
743 digest
[13] = (l
>> 8) & 0xff;
744 digest
[14] = (l
>> 16) & 0xff;
746 l
= itoa64_to_int (buf
[20]) << 0;
747 l
|= itoa64_to_int (buf
[21]) << 6;
749 digest
[15] = (l
>> 0) & 0xff;
752 void phpass_encode (unsigned char digest
[16], unsigned char buf
[22])
756 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
758 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
759 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
760 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
761 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
763 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
765 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
770 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
772 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[11] = int_to_itoa64 (l
& 0x3f);
777 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
779 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[15] = int_to_itoa64 (l
& 0x3f);
784 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
786 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[19] = int_to_itoa64 (l
& 0x3f);
791 l
= (digest
[15] << 0);
793 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[21] = int_to_itoa64 (l
& 0x3f);
797 void md5crypt_decode (unsigned char digest
[16], unsigned char buf
[22])
801 l
= itoa64_to_int (buf
[ 0]) << 0;
802 l
|= itoa64_to_int (buf
[ 1]) << 6;
803 l
|= itoa64_to_int (buf
[ 2]) << 12;
804 l
|= itoa64_to_int (buf
[ 3]) << 18;
806 digest
[ 0] = (l
>> 16) & 0xff;
807 digest
[ 6] = (l
>> 8) & 0xff;
808 digest
[12] = (l
>> 0) & 0xff;
810 l
= itoa64_to_int (buf
[ 4]) << 0;
811 l
|= itoa64_to_int (buf
[ 5]) << 6;
812 l
|= itoa64_to_int (buf
[ 6]) << 12;
813 l
|= itoa64_to_int (buf
[ 7]) << 18;
815 digest
[ 1] = (l
>> 16) & 0xff;
816 digest
[ 7] = (l
>> 8) & 0xff;
817 digest
[13] = (l
>> 0) & 0xff;
819 l
= itoa64_to_int (buf
[ 8]) << 0;
820 l
|= itoa64_to_int (buf
[ 9]) << 6;
821 l
|= itoa64_to_int (buf
[10]) << 12;
822 l
|= itoa64_to_int (buf
[11]) << 18;
824 digest
[ 2] = (l
>> 16) & 0xff;
825 digest
[ 8] = (l
>> 8) & 0xff;
826 digest
[14] = (l
>> 0) & 0xff;
828 l
= itoa64_to_int (buf
[12]) << 0;
829 l
|= itoa64_to_int (buf
[13]) << 6;
830 l
|= itoa64_to_int (buf
[14]) << 12;
831 l
|= itoa64_to_int (buf
[15]) << 18;
833 digest
[ 3] = (l
>> 16) & 0xff;
834 digest
[ 9] = (l
>> 8) & 0xff;
835 digest
[15] = (l
>> 0) & 0xff;
837 l
= itoa64_to_int (buf
[16]) << 0;
838 l
|= itoa64_to_int (buf
[17]) << 6;
839 l
|= itoa64_to_int (buf
[18]) << 12;
840 l
|= itoa64_to_int (buf
[19]) << 18;
842 digest
[ 4] = (l
>> 16) & 0xff;
843 digest
[10] = (l
>> 8) & 0xff;
844 digest
[ 5] = (l
>> 0) & 0xff;
846 l
= itoa64_to_int (buf
[20]) << 0;
847 l
|= itoa64_to_int (buf
[21]) << 6;
849 digest
[11] = (l
>> 0) & 0xff;
852 void md5crypt_encode (unsigned char digest
[16], unsigned char buf
[22])
856 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
858 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
859 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
860 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
865 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
872 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
879 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
886 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 l
= (digest
[11] << 0);
893 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 void sha512crypt_decode (unsigned char digest
[64], unsigned char buf
[86])
901 l
= itoa64_to_int (buf
[ 0]) << 0;
902 l
|= itoa64_to_int (buf
[ 1]) << 6;
903 l
|= itoa64_to_int (buf
[ 2]) << 12;
904 l
|= itoa64_to_int (buf
[ 3]) << 18;
906 digest
[ 0] = (l
>> 16) & 0xff;
907 digest
[21] = (l
>> 8) & 0xff;
908 digest
[42] = (l
>> 0) & 0xff;
910 l
= itoa64_to_int (buf
[ 4]) << 0;
911 l
|= itoa64_to_int (buf
[ 5]) << 6;
912 l
|= itoa64_to_int (buf
[ 6]) << 12;
913 l
|= itoa64_to_int (buf
[ 7]) << 18;
915 digest
[22] = (l
>> 16) & 0xff;
916 digest
[43] = (l
>> 8) & 0xff;
917 digest
[ 1] = (l
>> 0) & 0xff;
919 l
= itoa64_to_int (buf
[ 8]) << 0;
920 l
|= itoa64_to_int (buf
[ 9]) << 6;
921 l
|= itoa64_to_int (buf
[10]) << 12;
922 l
|= itoa64_to_int (buf
[11]) << 18;
924 digest
[44] = (l
>> 16) & 0xff;
925 digest
[ 2] = (l
>> 8) & 0xff;
926 digest
[23] = (l
>> 0) & 0xff;
928 l
= itoa64_to_int (buf
[12]) << 0;
929 l
|= itoa64_to_int (buf
[13]) << 6;
930 l
|= itoa64_to_int (buf
[14]) << 12;
931 l
|= itoa64_to_int (buf
[15]) << 18;
933 digest
[ 3] = (l
>> 16) & 0xff;
934 digest
[24] = (l
>> 8) & 0xff;
935 digest
[45] = (l
>> 0) & 0xff;
937 l
= itoa64_to_int (buf
[16]) << 0;
938 l
|= itoa64_to_int (buf
[17]) << 6;
939 l
|= itoa64_to_int (buf
[18]) << 12;
940 l
|= itoa64_to_int (buf
[19]) << 18;
942 digest
[25] = (l
>> 16) & 0xff;
943 digest
[46] = (l
>> 8) & 0xff;
944 digest
[ 4] = (l
>> 0) & 0xff;
946 l
= itoa64_to_int (buf
[20]) << 0;
947 l
|= itoa64_to_int (buf
[21]) << 6;
948 l
|= itoa64_to_int (buf
[22]) << 12;
949 l
|= itoa64_to_int (buf
[23]) << 18;
951 digest
[47] = (l
>> 16) & 0xff;
952 digest
[ 5] = (l
>> 8) & 0xff;
953 digest
[26] = (l
>> 0) & 0xff;
955 l
= itoa64_to_int (buf
[24]) << 0;
956 l
|= itoa64_to_int (buf
[25]) << 6;
957 l
|= itoa64_to_int (buf
[26]) << 12;
958 l
|= itoa64_to_int (buf
[27]) << 18;
960 digest
[ 6] = (l
>> 16) & 0xff;
961 digest
[27] = (l
>> 8) & 0xff;
962 digest
[48] = (l
>> 0) & 0xff;
964 l
= itoa64_to_int (buf
[28]) << 0;
965 l
|= itoa64_to_int (buf
[29]) << 6;
966 l
|= itoa64_to_int (buf
[30]) << 12;
967 l
|= itoa64_to_int (buf
[31]) << 18;
969 digest
[28] = (l
>> 16) & 0xff;
970 digest
[49] = (l
>> 8) & 0xff;
971 digest
[ 7] = (l
>> 0) & 0xff;
973 l
= itoa64_to_int (buf
[32]) << 0;
974 l
|= itoa64_to_int (buf
[33]) << 6;
975 l
|= itoa64_to_int (buf
[34]) << 12;
976 l
|= itoa64_to_int (buf
[35]) << 18;
978 digest
[50] = (l
>> 16) & 0xff;
979 digest
[ 8] = (l
>> 8) & 0xff;
980 digest
[29] = (l
>> 0) & 0xff;
982 l
= itoa64_to_int (buf
[36]) << 0;
983 l
|= itoa64_to_int (buf
[37]) << 6;
984 l
|= itoa64_to_int (buf
[38]) << 12;
985 l
|= itoa64_to_int (buf
[39]) << 18;
987 digest
[ 9] = (l
>> 16) & 0xff;
988 digest
[30] = (l
>> 8) & 0xff;
989 digest
[51] = (l
>> 0) & 0xff;
991 l
= itoa64_to_int (buf
[40]) << 0;
992 l
|= itoa64_to_int (buf
[41]) << 6;
993 l
|= itoa64_to_int (buf
[42]) << 12;
994 l
|= itoa64_to_int (buf
[43]) << 18;
996 digest
[31] = (l
>> 16) & 0xff;
997 digest
[52] = (l
>> 8) & 0xff;
998 digest
[10] = (l
>> 0) & 0xff;
1000 l
= itoa64_to_int (buf
[44]) << 0;
1001 l
|= itoa64_to_int (buf
[45]) << 6;
1002 l
|= itoa64_to_int (buf
[46]) << 12;
1003 l
|= itoa64_to_int (buf
[47]) << 18;
1005 digest
[53] = (l
>> 16) & 0xff;
1006 digest
[11] = (l
>> 8) & 0xff;
1007 digest
[32] = (l
>> 0) & 0xff;
1009 l
= itoa64_to_int (buf
[48]) << 0;
1010 l
|= itoa64_to_int (buf
[49]) << 6;
1011 l
|= itoa64_to_int (buf
[50]) << 12;
1012 l
|= itoa64_to_int (buf
[51]) << 18;
1014 digest
[12] = (l
>> 16) & 0xff;
1015 digest
[33] = (l
>> 8) & 0xff;
1016 digest
[54] = (l
>> 0) & 0xff;
1018 l
= itoa64_to_int (buf
[52]) << 0;
1019 l
|= itoa64_to_int (buf
[53]) << 6;
1020 l
|= itoa64_to_int (buf
[54]) << 12;
1021 l
|= itoa64_to_int (buf
[55]) << 18;
1023 digest
[34] = (l
>> 16) & 0xff;
1024 digest
[55] = (l
>> 8) & 0xff;
1025 digest
[13] = (l
>> 0) & 0xff;
1027 l
= itoa64_to_int (buf
[56]) << 0;
1028 l
|= itoa64_to_int (buf
[57]) << 6;
1029 l
|= itoa64_to_int (buf
[58]) << 12;
1030 l
|= itoa64_to_int (buf
[59]) << 18;
1032 digest
[56] = (l
>> 16) & 0xff;
1033 digest
[14] = (l
>> 8) & 0xff;
1034 digest
[35] = (l
>> 0) & 0xff;
1036 l
= itoa64_to_int (buf
[60]) << 0;
1037 l
|= itoa64_to_int (buf
[61]) << 6;
1038 l
|= itoa64_to_int (buf
[62]) << 12;
1039 l
|= itoa64_to_int (buf
[63]) << 18;
1041 digest
[15] = (l
>> 16) & 0xff;
1042 digest
[36] = (l
>> 8) & 0xff;
1043 digest
[57] = (l
>> 0) & 0xff;
1045 l
= itoa64_to_int (buf
[64]) << 0;
1046 l
|= itoa64_to_int (buf
[65]) << 6;
1047 l
|= itoa64_to_int (buf
[66]) << 12;
1048 l
|= itoa64_to_int (buf
[67]) << 18;
1050 digest
[37] = (l
>> 16) & 0xff;
1051 digest
[58] = (l
>> 8) & 0xff;
1052 digest
[16] = (l
>> 0) & 0xff;
1054 l
= itoa64_to_int (buf
[68]) << 0;
1055 l
|= itoa64_to_int (buf
[69]) << 6;
1056 l
|= itoa64_to_int (buf
[70]) << 12;
1057 l
|= itoa64_to_int (buf
[71]) << 18;
1059 digest
[59] = (l
>> 16) & 0xff;
1060 digest
[17] = (l
>> 8) & 0xff;
1061 digest
[38] = (l
>> 0) & 0xff;
1063 l
= itoa64_to_int (buf
[72]) << 0;
1064 l
|= itoa64_to_int (buf
[73]) << 6;
1065 l
|= itoa64_to_int (buf
[74]) << 12;
1066 l
|= itoa64_to_int (buf
[75]) << 18;
1068 digest
[18] = (l
>> 16) & 0xff;
1069 digest
[39] = (l
>> 8) & 0xff;
1070 digest
[60] = (l
>> 0) & 0xff;
1072 l
= itoa64_to_int (buf
[76]) << 0;
1073 l
|= itoa64_to_int (buf
[77]) << 6;
1074 l
|= itoa64_to_int (buf
[78]) << 12;
1075 l
|= itoa64_to_int (buf
[79]) << 18;
1077 digest
[40] = (l
>> 16) & 0xff;
1078 digest
[61] = (l
>> 8) & 0xff;
1079 digest
[19] = (l
>> 0) & 0xff;
1081 l
= itoa64_to_int (buf
[80]) << 0;
1082 l
|= itoa64_to_int (buf
[81]) << 6;
1083 l
|= itoa64_to_int (buf
[82]) << 12;
1084 l
|= itoa64_to_int (buf
[83]) << 18;
1086 digest
[62] = (l
>> 16) & 0xff;
1087 digest
[20] = (l
>> 8) & 0xff;
1088 digest
[41] = (l
>> 0) & 0xff;
1090 l
= itoa64_to_int (buf
[84]) << 0;
1091 l
|= itoa64_to_int (buf
[85]) << 6;
1093 digest
[63] = (l
>> 0) & 0xff;
1096 void sha512crypt_encode (unsigned char digest
[64], unsigned char buf
[86])
1100 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1102 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1103 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1104 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1109 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1116 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1123 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1130 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1137 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1144 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1151 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1158 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1165 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1172 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1179 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1186 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1193 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1200 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1207 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1214 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1221 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1228 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1235 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1242 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 l
= 0 | 0 | (digest
[63] << 0);
1249 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 void sha1aix_decode (unsigned char digest
[20], unsigned char buf
[27])
1257 l
= itoa64_to_int (buf
[ 0]) << 0;
1258 l
|= itoa64_to_int (buf
[ 1]) << 6;
1259 l
|= itoa64_to_int (buf
[ 2]) << 12;
1260 l
|= itoa64_to_int (buf
[ 3]) << 18;
1262 digest
[ 2] = (l
>> 0) & 0xff;
1263 digest
[ 1] = (l
>> 8) & 0xff;
1264 digest
[ 0] = (l
>> 16) & 0xff;
1266 l
= itoa64_to_int (buf
[ 4]) << 0;
1267 l
|= itoa64_to_int (buf
[ 5]) << 6;
1268 l
|= itoa64_to_int (buf
[ 6]) << 12;
1269 l
|= itoa64_to_int (buf
[ 7]) << 18;
1271 digest
[ 5] = (l
>> 0) & 0xff;
1272 digest
[ 4] = (l
>> 8) & 0xff;
1273 digest
[ 3] = (l
>> 16) & 0xff;
1275 l
= itoa64_to_int (buf
[ 8]) << 0;
1276 l
|= itoa64_to_int (buf
[ 9]) << 6;
1277 l
|= itoa64_to_int (buf
[10]) << 12;
1278 l
|= itoa64_to_int (buf
[11]) << 18;
1280 digest
[ 8] = (l
>> 0) & 0xff;
1281 digest
[ 7] = (l
>> 8) & 0xff;
1282 digest
[ 6] = (l
>> 16) & 0xff;
1284 l
= itoa64_to_int (buf
[12]) << 0;
1285 l
|= itoa64_to_int (buf
[13]) << 6;
1286 l
|= itoa64_to_int (buf
[14]) << 12;
1287 l
|= itoa64_to_int (buf
[15]) << 18;
1289 digest
[11] = (l
>> 0) & 0xff;
1290 digest
[10] = (l
>> 8) & 0xff;
1291 digest
[ 9] = (l
>> 16) & 0xff;
1293 l
= itoa64_to_int (buf
[16]) << 0;
1294 l
|= itoa64_to_int (buf
[17]) << 6;
1295 l
|= itoa64_to_int (buf
[18]) << 12;
1296 l
|= itoa64_to_int (buf
[19]) << 18;
1298 digest
[14] = (l
>> 0) & 0xff;
1299 digest
[13] = (l
>> 8) & 0xff;
1300 digest
[12] = (l
>> 16) & 0xff;
1302 l
= itoa64_to_int (buf
[20]) << 0;
1303 l
|= itoa64_to_int (buf
[21]) << 6;
1304 l
|= itoa64_to_int (buf
[22]) << 12;
1305 l
|= itoa64_to_int (buf
[23]) << 18;
1307 digest
[17] = (l
>> 0) & 0xff;
1308 digest
[16] = (l
>> 8) & 0xff;
1309 digest
[15] = (l
>> 16) & 0xff;
1311 l
= itoa64_to_int (buf
[24]) << 0;
1312 l
|= itoa64_to_int (buf
[25]) << 6;
1313 l
|= itoa64_to_int (buf
[26]) << 12;
1315 digest
[19] = (l
>> 8) & 0xff;
1316 digest
[18] = (l
>> 16) & 0xff;
1319 void sha1aix_encode (unsigned char digest
[20], unsigned char buf
[27])
1323 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1325 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1326 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1327 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1328 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1330 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1332 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1337 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1339 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[11] = int_to_itoa64 (l
& 0x3f);
1344 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1346 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[15] = int_to_itoa64 (l
& 0x3f);
1351 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1353 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[19] = int_to_itoa64 (l
& 0x3f);
1358 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1360 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[23] = int_to_itoa64 (l
& 0x3f);
1365 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1367 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[26] = int_to_itoa64 (l
& 0x3f);
1372 void sha256aix_decode (unsigned char digest
[32], unsigned char buf
[43])
1376 l
= itoa64_to_int (buf
[ 0]) << 0;
1377 l
|= itoa64_to_int (buf
[ 1]) << 6;
1378 l
|= itoa64_to_int (buf
[ 2]) << 12;
1379 l
|= itoa64_to_int (buf
[ 3]) << 18;
1381 digest
[ 2] = (l
>> 0) & 0xff;
1382 digest
[ 1] = (l
>> 8) & 0xff;
1383 digest
[ 0] = (l
>> 16) & 0xff;
1385 l
= itoa64_to_int (buf
[ 4]) << 0;
1386 l
|= itoa64_to_int (buf
[ 5]) << 6;
1387 l
|= itoa64_to_int (buf
[ 6]) << 12;
1388 l
|= itoa64_to_int (buf
[ 7]) << 18;
1390 digest
[ 5] = (l
>> 0) & 0xff;
1391 digest
[ 4] = (l
>> 8) & 0xff;
1392 digest
[ 3] = (l
>> 16) & 0xff;
1394 l
= itoa64_to_int (buf
[ 8]) << 0;
1395 l
|= itoa64_to_int (buf
[ 9]) << 6;
1396 l
|= itoa64_to_int (buf
[10]) << 12;
1397 l
|= itoa64_to_int (buf
[11]) << 18;
1399 digest
[ 8] = (l
>> 0) & 0xff;
1400 digest
[ 7] = (l
>> 8) & 0xff;
1401 digest
[ 6] = (l
>> 16) & 0xff;
1403 l
= itoa64_to_int (buf
[12]) << 0;
1404 l
|= itoa64_to_int (buf
[13]) << 6;
1405 l
|= itoa64_to_int (buf
[14]) << 12;
1406 l
|= itoa64_to_int (buf
[15]) << 18;
1408 digest
[11] = (l
>> 0) & 0xff;
1409 digest
[10] = (l
>> 8) & 0xff;
1410 digest
[ 9] = (l
>> 16) & 0xff;
1412 l
= itoa64_to_int (buf
[16]) << 0;
1413 l
|= itoa64_to_int (buf
[17]) << 6;
1414 l
|= itoa64_to_int (buf
[18]) << 12;
1415 l
|= itoa64_to_int (buf
[19]) << 18;
1417 digest
[14] = (l
>> 0) & 0xff;
1418 digest
[13] = (l
>> 8) & 0xff;
1419 digest
[12] = (l
>> 16) & 0xff;
1421 l
= itoa64_to_int (buf
[20]) << 0;
1422 l
|= itoa64_to_int (buf
[21]) << 6;
1423 l
|= itoa64_to_int (buf
[22]) << 12;
1424 l
|= itoa64_to_int (buf
[23]) << 18;
1426 digest
[17] = (l
>> 0) & 0xff;
1427 digest
[16] = (l
>> 8) & 0xff;
1428 digest
[15] = (l
>> 16) & 0xff;
1430 l
= itoa64_to_int (buf
[24]) << 0;
1431 l
|= itoa64_to_int (buf
[25]) << 6;
1432 l
|= itoa64_to_int (buf
[26]) << 12;
1433 l
|= itoa64_to_int (buf
[27]) << 18;
1435 digest
[20] = (l
>> 0) & 0xff;
1436 digest
[19] = (l
>> 8) & 0xff;
1437 digest
[18] = (l
>> 16) & 0xff;
1439 l
= itoa64_to_int (buf
[28]) << 0;
1440 l
|= itoa64_to_int (buf
[29]) << 6;
1441 l
|= itoa64_to_int (buf
[30]) << 12;
1442 l
|= itoa64_to_int (buf
[31]) << 18;
1444 digest
[23] = (l
>> 0) & 0xff;
1445 digest
[22] = (l
>> 8) & 0xff;
1446 digest
[21] = (l
>> 16) & 0xff;
1448 l
= itoa64_to_int (buf
[32]) << 0;
1449 l
|= itoa64_to_int (buf
[33]) << 6;
1450 l
|= itoa64_to_int (buf
[34]) << 12;
1451 l
|= itoa64_to_int (buf
[35]) << 18;
1453 digest
[26] = (l
>> 0) & 0xff;
1454 digest
[25] = (l
>> 8) & 0xff;
1455 digest
[24] = (l
>> 16) & 0xff;
1457 l
= itoa64_to_int (buf
[36]) << 0;
1458 l
|= itoa64_to_int (buf
[37]) << 6;
1459 l
|= itoa64_to_int (buf
[38]) << 12;
1460 l
|= itoa64_to_int (buf
[39]) << 18;
1462 digest
[29] = (l
>> 0) & 0xff;
1463 digest
[28] = (l
>> 8) & 0xff;
1464 digest
[27] = (l
>> 16) & 0xff;
1466 l
= itoa64_to_int (buf
[40]) << 0;
1467 l
|= itoa64_to_int (buf
[41]) << 6;
1468 l
|= itoa64_to_int (buf
[42]) << 12;
1470 //digest[32] = (l >> 0) & 0xff;
1471 digest
[31] = (l
>> 8) & 0xff;
1472 digest
[30] = (l
>> 16) & 0xff;
1475 void sha256aix_encode (unsigned char digest
[32], unsigned char buf
[43])
1479 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1481 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1482 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1483 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1484 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1486 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1488 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1493 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1495 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[11] = int_to_itoa64 (l
& 0x3f);
1500 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1502 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[15] = int_to_itoa64 (l
& 0x3f);
1507 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1509 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[19] = int_to_itoa64 (l
& 0x3f);
1514 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1516 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[23] = int_to_itoa64 (l
& 0x3f);
1521 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1523 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[27] = int_to_itoa64 (l
& 0x3f);
1528 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1530 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[31] = int_to_itoa64 (l
& 0x3f);
1535 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1537 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[35] = int_to_itoa64 (l
& 0x3f);
1542 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1544 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[39] = int_to_itoa64 (l
& 0x3f);
1549 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1551 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[42] = int_to_itoa64 (l
& 0x3f);
1556 void sha512aix_decode (unsigned char digest
[64], unsigned char buf
[86])
1560 l
= itoa64_to_int (buf
[ 0]) << 0;
1561 l
|= itoa64_to_int (buf
[ 1]) << 6;
1562 l
|= itoa64_to_int (buf
[ 2]) << 12;
1563 l
|= itoa64_to_int (buf
[ 3]) << 18;
1565 digest
[ 2] = (l
>> 0) & 0xff;
1566 digest
[ 1] = (l
>> 8) & 0xff;
1567 digest
[ 0] = (l
>> 16) & 0xff;
1569 l
= itoa64_to_int (buf
[ 4]) << 0;
1570 l
|= itoa64_to_int (buf
[ 5]) << 6;
1571 l
|= itoa64_to_int (buf
[ 6]) << 12;
1572 l
|= itoa64_to_int (buf
[ 7]) << 18;
1574 digest
[ 5] = (l
>> 0) & 0xff;
1575 digest
[ 4] = (l
>> 8) & 0xff;
1576 digest
[ 3] = (l
>> 16) & 0xff;
1578 l
= itoa64_to_int (buf
[ 8]) << 0;
1579 l
|= itoa64_to_int (buf
[ 9]) << 6;
1580 l
|= itoa64_to_int (buf
[10]) << 12;
1581 l
|= itoa64_to_int (buf
[11]) << 18;
1583 digest
[ 8] = (l
>> 0) & 0xff;
1584 digest
[ 7] = (l
>> 8) & 0xff;
1585 digest
[ 6] = (l
>> 16) & 0xff;
1587 l
= itoa64_to_int (buf
[12]) << 0;
1588 l
|= itoa64_to_int (buf
[13]) << 6;
1589 l
|= itoa64_to_int (buf
[14]) << 12;
1590 l
|= itoa64_to_int (buf
[15]) << 18;
1592 digest
[11] = (l
>> 0) & 0xff;
1593 digest
[10] = (l
>> 8) & 0xff;
1594 digest
[ 9] = (l
>> 16) & 0xff;
1596 l
= itoa64_to_int (buf
[16]) << 0;
1597 l
|= itoa64_to_int (buf
[17]) << 6;
1598 l
|= itoa64_to_int (buf
[18]) << 12;
1599 l
|= itoa64_to_int (buf
[19]) << 18;
1601 digest
[14] = (l
>> 0) & 0xff;
1602 digest
[13] = (l
>> 8) & 0xff;
1603 digest
[12] = (l
>> 16) & 0xff;
1605 l
= itoa64_to_int (buf
[20]) << 0;
1606 l
|= itoa64_to_int (buf
[21]) << 6;
1607 l
|= itoa64_to_int (buf
[22]) << 12;
1608 l
|= itoa64_to_int (buf
[23]) << 18;
1610 digest
[17] = (l
>> 0) & 0xff;
1611 digest
[16] = (l
>> 8) & 0xff;
1612 digest
[15] = (l
>> 16) & 0xff;
1614 l
= itoa64_to_int (buf
[24]) << 0;
1615 l
|= itoa64_to_int (buf
[25]) << 6;
1616 l
|= itoa64_to_int (buf
[26]) << 12;
1617 l
|= itoa64_to_int (buf
[27]) << 18;
1619 digest
[20] = (l
>> 0) & 0xff;
1620 digest
[19] = (l
>> 8) & 0xff;
1621 digest
[18] = (l
>> 16) & 0xff;
1623 l
= itoa64_to_int (buf
[28]) << 0;
1624 l
|= itoa64_to_int (buf
[29]) << 6;
1625 l
|= itoa64_to_int (buf
[30]) << 12;
1626 l
|= itoa64_to_int (buf
[31]) << 18;
1628 digest
[23] = (l
>> 0) & 0xff;
1629 digest
[22] = (l
>> 8) & 0xff;
1630 digest
[21] = (l
>> 16) & 0xff;
1632 l
= itoa64_to_int (buf
[32]) << 0;
1633 l
|= itoa64_to_int (buf
[33]) << 6;
1634 l
|= itoa64_to_int (buf
[34]) << 12;
1635 l
|= itoa64_to_int (buf
[35]) << 18;
1637 digest
[26] = (l
>> 0) & 0xff;
1638 digest
[25] = (l
>> 8) & 0xff;
1639 digest
[24] = (l
>> 16) & 0xff;
1641 l
= itoa64_to_int (buf
[36]) << 0;
1642 l
|= itoa64_to_int (buf
[37]) << 6;
1643 l
|= itoa64_to_int (buf
[38]) << 12;
1644 l
|= itoa64_to_int (buf
[39]) << 18;
1646 digest
[29] = (l
>> 0) & 0xff;
1647 digest
[28] = (l
>> 8) & 0xff;
1648 digest
[27] = (l
>> 16) & 0xff;
1650 l
= itoa64_to_int (buf
[40]) << 0;
1651 l
|= itoa64_to_int (buf
[41]) << 6;
1652 l
|= itoa64_to_int (buf
[42]) << 12;
1653 l
|= itoa64_to_int (buf
[43]) << 18;
1655 digest
[32] = (l
>> 0) & 0xff;
1656 digest
[31] = (l
>> 8) & 0xff;
1657 digest
[30] = (l
>> 16) & 0xff;
1659 l
= itoa64_to_int (buf
[44]) << 0;
1660 l
|= itoa64_to_int (buf
[45]) << 6;
1661 l
|= itoa64_to_int (buf
[46]) << 12;
1662 l
|= itoa64_to_int (buf
[47]) << 18;
1664 digest
[35] = (l
>> 0) & 0xff;
1665 digest
[34] = (l
>> 8) & 0xff;
1666 digest
[33] = (l
>> 16) & 0xff;
1668 l
= itoa64_to_int (buf
[48]) << 0;
1669 l
|= itoa64_to_int (buf
[49]) << 6;
1670 l
|= itoa64_to_int (buf
[50]) << 12;
1671 l
|= itoa64_to_int (buf
[51]) << 18;
1673 digest
[38] = (l
>> 0) & 0xff;
1674 digest
[37] = (l
>> 8) & 0xff;
1675 digest
[36] = (l
>> 16) & 0xff;
1677 l
= itoa64_to_int (buf
[52]) << 0;
1678 l
|= itoa64_to_int (buf
[53]) << 6;
1679 l
|= itoa64_to_int (buf
[54]) << 12;
1680 l
|= itoa64_to_int (buf
[55]) << 18;
1682 digest
[41] = (l
>> 0) & 0xff;
1683 digest
[40] = (l
>> 8) & 0xff;
1684 digest
[39] = (l
>> 16) & 0xff;
1686 l
= itoa64_to_int (buf
[56]) << 0;
1687 l
|= itoa64_to_int (buf
[57]) << 6;
1688 l
|= itoa64_to_int (buf
[58]) << 12;
1689 l
|= itoa64_to_int (buf
[59]) << 18;
1691 digest
[44] = (l
>> 0) & 0xff;
1692 digest
[43] = (l
>> 8) & 0xff;
1693 digest
[42] = (l
>> 16) & 0xff;
1695 l
= itoa64_to_int (buf
[60]) << 0;
1696 l
|= itoa64_to_int (buf
[61]) << 6;
1697 l
|= itoa64_to_int (buf
[62]) << 12;
1698 l
|= itoa64_to_int (buf
[63]) << 18;
1700 digest
[47] = (l
>> 0) & 0xff;
1701 digest
[46] = (l
>> 8) & 0xff;
1702 digest
[45] = (l
>> 16) & 0xff;
1704 l
= itoa64_to_int (buf
[64]) << 0;
1705 l
|= itoa64_to_int (buf
[65]) << 6;
1706 l
|= itoa64_to_int (buf
[66]) << 12;
1707 l
|= itoa64_to_int (buf
[67]) << 18;
1709 digest
[50] = (l
>> 0) & 0xff;
1710 digest
[49] = (l
>> 8) & 0xff;
1711 digest
[48] = (l
>> 16) & 0xff;
1713 l
= itoa64_to_int (buf
[68]) << 0;
1714 l
|= itoa64_to_int (buf
[69]) << 6;
1715 l
|= itoa64_to_int (buf
[70]) << 12;
1716 l
|= itoa64_to_int (buf
[71]) << 18;
1718 digest
[53] = (l
>> 0) & 0xff;
1719 digest
[52] = (l
>> 8) & 0xff;
1720 digest
[51] = (l
>> 16) & 0xff;
1722 l
= itoa64_to_int (buf
[72]) << 0;
1723 l
|= itoa64_to_int (buf
[73]) << 6;
1724 l
|= itoa64_to_int (buf
[74]) << 12;
1725 l
|= itoa64_to_int (buf
[75]) << 18;
1727 digest
[56] = (l
>> 0) & 0xff;
1728 digest
[55] = (l
>> 8) & 0xff;
1729 digest
[54] = (l
>> 16) & 0xff;
1731 l
= itoa64_to_int (buf
[76]) << 0;
1732 l
|= itoa64_to_int (buf
[77]) << 6;
1733 l
|= itoa64_to_int (buf
[78]) << 12;
1734 l
|= itoa64_to_int (buf
[79]) << 18;
1736 digest
[59] = (l
>> 0) & 0xff;
1737 digest
[58] = (l
>> 8) & 0xff;
1738 digest
[57] = (l
>> 16) & 0xff;
1740 l
= itoa64_to_int (buf
[80]) << 0;
1741 l
|= itoa64_to_int (buf
[81]) << 6;
1742 l
|= itoa64_to_int (buf
[82]) << 12;
1743 l
|= itoa64_to_int (buf
[83]) << 18;
1745 digest
[62] = (l
>> 0) & 0xff;
1746 digest
[61] = (l
>> 8) & 0xff;
1747 digest
[60] = (l
>> 16) & 0xff;
1749 l
= itoa64_to_int (buf
[84]) << 0;
1750 l
|= itoa64_to_int (buf
[85]) << 6;
1752 digest
[63] = (l
>> 16) & 0xff;
1755 void sha512aix_encode (unsigned char digest
[64], unsigned char buf
[86])
1759 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1761 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1762 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1763 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1764 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1766 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1768 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1773 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1775 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[11] = int_to_itoa64 (l
& 0x3f);
1780 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1782 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[15] = int_to_itoa64 (l
& 0x3f);
1787 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1789 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[19] = int_to_itoa64 (l
& 0x3f);
1794 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1796 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[23] = int_to_itoa64 (l
& 0x3f);
1801 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1803 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[27] = int_to_itoa64 (l
& 0x3f);
1808 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1810 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[31] = int_to_itoa64 (l
& 0x3f);
1815 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1817 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[35] = int_to_itoa64 (l
& 0x3f);
1822 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1824 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[39] = int_to_itoa64 (l
& 0x3f);
1829 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1831 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[43] = int_to_itoa64 (l
& 0x3f);
1836 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1838 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[47] = int_to_itoa64 (l
& 0x3f);
1843 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1845 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[51] = int_to_itoa64 (l
& 0x3f);
1850 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1852 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[55] = int_to_itoa64 (l
& 0x3f);
1857 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1859 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[59] = int_to_itoa64 (l
& 0x3f);
1864 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1866 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[63] = int_to_itoa64 (l
& 0x3f);
1871 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1873 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[67] = int_to_itoa64 (l
& 0x3f);
1878 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1880 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[71] = int_to_itoa64 (l
& 0x3f);
1885 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1887 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[75] = int_to_itoa64 (l
& 0x3f);
1892 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1894 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[79] = int_to_itoa64 (l
& 0x3f);
1899 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1901 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[83] = int_to_itoa64 (l
& 0x3f);
1906 l
= 0 | 0 | (digest
[63] << 16);
1908 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 void sha256crypt_decode (unsigned char digest
[32], unsigned char buf
[43])
1916 l
= itoa64_to_int (buf
[ 0]) << 0;
1917 l
|= itoa64_to_int (buf
[ 1]) << 6;
1918 l
|= itoa64_to_int (buf
[ 2]) << 12;
1919 l
|= itoa64_to_int (buf
[ 3]) << 18;
1921 digest
[ 0] = (l
>> 16) & 0xff;
1922 digest
[10] = (l
>> 8) & 0xff;
1923 digest
[20] = (l
>> 0) & 0xff;
1925 l
= itoa64_to_int (buf
[ 4]) << 0;
1926 l
|= itoa64_to_int (buf
[ 5]) << 6;
1927 l
|= itoa64_to_int (buf
[ 6]) << 12;
1928 l
|= itoa64_to_int (buf
[ 7]) << 18;
1930 digest
[21] = (l
>> 16) & 0xff;
1931 digest
[ 1] = (l
>> 8) & 0xff;
1932 digest
[11] = (l
>> 0) & 0xff;
1934 l
= itoa64_to_int (buf
[ 8]) << 0;
1935 l
|= itoa64_to_int (buf
[ 9]) << 6;
1936 l
|= itoa64_to_int (buf
[10]) << 12;
1937 l
|= itoa64_to_int (buf
[11]) << 18;
1939 digest
[12] = (l
>> 16) & 0xff;
1940 digest
[22] = (l
>> 8) & 0xff;
1941 digest
[ 2] = (l
>> 0) & 0xff;
1943 l
= itoa64_to_int (buf
[12]) << 0;
1944 l
|= itoa64_to_int (buf
[13]) << 6;
1945 l
|= itoa64_to_int (buf
[14]) << 12;
1946 l
|= itoa64_to_int (buf
[15]) << 18;
1948 digest
[ 3] = (l
>> 16) & 0xff;
1949 digest
[13] = (l
>> 8) & 0xff;
1950 digest
[23] = (l
>> 0) & 0xff;
1952 l
= itoa64_to_int (buf
[16]) << 0;
1953 l
|= itoa64_to_int (buf
[17]) << 6;
1954 l
|= itoa64_to_int (buf
[18]) << 12;
1955 l
|= itoa64_to_int (buf
[19]) << 18;
1957 digest
[24] = (l
>> 16) & 0xff;
1958 digest
[ 4] = (l
>> 8) & 0xff;
1959 digest
[14] = (l
>> 0) & 0xff;
1961 l
= itoa64_to_int (buf
[20]) << 0;
1962 l
|= itoa64_to_int (buf
[21]) << 6;
1963 l
|= itoa64_to_int (buf
[22]) << 12;
1964 l
|= itoa64_to_int (buf
[23]) << 18;
1966 digest
[15] = (l
>> 16) & 0xff;
1967 digest
[25] = (l
>> 8) & 0xff;
1968 digest
[ 5] = (l
>> 0) & 0xff;
1970 l
= itoa64_to_int (buf
[24]) << 0;
1971 l
|= itoa64_to_int (buf
[25]) << 6;
1972 l
|= itoa64_to_int (buf
[26]) << 12;
1973 l
|= itoa64_to_int (buf
[27]) << 18;
1975 digest
[ 6] = (l
>> 16) & 0xff;
1976 digest
[16] = (l
>> 8) & 0xff;
1977 digest
[26] = (l
>> 0) & 0xff;
1979 l
= itoa64_to_int (buf
[28]) << 0;
1980 l
|= itoa64_to_int (buf
[29]) << 6;
1981 l
|= itoa64_to_int (buf
[30]) << 12;
1982 l
|= itoa64_to_int (buf
[31]) << 18;
1984 digest
[27] = (l
>> 16) & 0xff;
1985 digest
[ 7] = (l
>> 8) & 0xff;
1986 digest
[17] = (l
>> 0) & 0xff;
1988 l
= itoa64_to_int (buf
[32]) << 0;
1989 l
|= itoa64_to_int (buf
[33]) << 6;
1990 l
|= itoa64_to_int (buf
[34]) << 12;
1991 l
|= itoa64_to_int (buf
[35]) << 18;
1993 digest
[18] = (l
>> 16) & 0xff;
1994 digest
[28] = (l
>> 8) & 0xff;
1995 digest
[ 8] = (l
>> 0) & 0xff;
1997 l
= itoa64_to_int (buf
[36]) << 0;
1998 l
|= itoa64_to_int (buf
[37]) << 6;
1999 l
|= itoa64_to_int (buf
[38]) << 12;
2000 l
|= itoa64_to_int (buf
[39]) << 18;
2002 digest
[ 9] = (l
>> 16) & 0xff;
2003 digest
[19] = (l
>> 8) & 0xff;
2004 digest
[29] = (l
>> 0) & 0xff;
2006 l
= itoa64_to_int (buf
[40]) << 0;
2007 l
|= itoa64_to_int (buf
[41]) << 6;
2008 l
|= itoa64_to_int (buf
[42]) << 12;
2010 digest
[31] = (l
>> 8) & 0xff;
2011 digest
[30] = (l
>> 0) & 0xff;
2014 void sha256crypt_encode (unsigned char digest
[32], unsigned char buf
[43])
2018 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2020 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2021 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2022 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2027 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2034 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2041 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2048 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2055 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2062 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2069 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2076 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2083 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2090 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[42] = int_to_itoa64 (l
& 0x3f);
2095 void drupal7_decode (unsigned char digest
[64], unsigned char buf
[44])
2099 l
= itoa64_to_int (buf
[ 0]) << 0;
2100 l
|= itoa64_to_int (buf
[ 1]) << 6;
2101 l
|= itoa64_to_int (buf
[ 2]) << 12;
2102 l
|= itoa64_to_int (buf
[ 3]) << 18;
2104 digest
[ 0] = (l
>> 0) & 0xff;
2105 digest
[ 1] = (l
>> 8) & 0xff;
2106 digest
[ 2] = (l
>> 16) & 0xff;
2108 l
= itoa64_to_int (buf
[ 4]) << 0;
2109 l
|= itoa64_to_int (buf
[ 5]) << 6;
2110 l
|= itoa64_to_int (buf
[ 6]) << 12;
2111 l
|= itoa64_to_int (buf
[ 7]) << 18;
2113 digest
[ 3] = (l
>> 0) & 0xff;
2114 digest
[ 4] = (l
>> 8) & 0xff;
2115 digest
[ 5] = (l
>> 16) & 0xff;
2117 l
= itoa64_to_int (buf
[ 8]) << 0;
2118 l
|= itoa64_to_int (buf
[ 9]) << 6;
2119 l
|= itoa64_to_int (buf
[10]) << 12;
2120 l
|= itoa64_to_int (buf
[11]) << 18;
2122 digest
[ 6] = (l
>> 0) & 0xff;
2123 digest
[ 7] = (l
>> 8) & 0xff;
2124 digest
[ 8] = (l
>> 16) & 0xff;
2126 l
= itoa64_to_int (buf
[12]) << 0;
2127 l
|= itoa64_to_int (buf
[13]) << 6;
2128 l
|= itoa64_to_int (buf
[14]) << 12;
2129 l
|= itoa64_to_int (buf
[15]) << 18;
2131 digest
[ 9] = (l
>> 0) & 0xff;
2132 digest
[10] = (l
>> 8) & 0xff;
2133 digest
[11] = (l
>> 16) & 0xff;
2135 l
= itoa64_to_int (buf
[16]) << 0;
2136 l
|= itoa64_to_int (buf
[17]) << 6;
2137 l
|= itoa64_to_int (buf
[18]) << 12;
2138 l
|= itoa64_to_int (buf
[19]) << 18;
2140 digest
[12] = (l
>> 0) & 0xff;
2141 digest
[13] = (l
>> 8) & 0xff;
2142 digest
[14] = (l
>> 16) & 0xff;
2144 l
= itoa64_to_int (buf
[20]) << 0;
2145 l
|= itoa64_to_int (buf
[21]) << 6;
2146 l
|= itoa64_to_int (buf
[22]) << 12;
2147 l
|= itoa64_to_int (buf
[23]) << 18;
2149 digest
[15] = (l
>> 0) & 0xff;
2150 digest
[16] = (l
>> 8) & 0xff;
2151 digest
[17] = (l
>> 16) & 0xff;
2153 l
= itoa64_to_int (buf
[24]) << 0;
2154 l
|= itoa64_to_int (buf
[25]) << 6;
2155 l
|= itoa64_to_int (buf
[26]) << 12;
2156 l
|= itoa64_to_int (buf
[27]) << 18;
2158 digest
[18] = (l
>> 0) & 0xff;
2159 digest
[19] = (l
>> 8) & 0xff;
2160 digest
[20] = (l
>> 16) & 0xff;
2162 l
= itoa64_to_int (buf
[28]) << 0;
2163 l
|= itoa64_to_int (buf
[29]) << 6;
2164 l
|= itoa64_to_int (buf
[30]) << 12;
2165 l
|= itoa64_to_int (buf
[31]) << 18;
2167 digest
[21] = (l
>> 0) & 0xff;
2168 digest
[22] = (l
>> 8) & 0xff;
2169 digest
[23] = (l
>> 16) & 0xff;
2171 l
= itoa64_to_int (buf
[32]) << 0;
2172 l
|= itoa64_to_int (buf
[33]) << 6;
2173 l
|= itoa64_to_int (buf
[34]) << 12;
2174 l
|= itoa64_to_int (buf
[35]) << 18;
2176 digest
[24] = (l
>> 0) & 0xff;
2177 digest
[25] = (l
>> 8) & 0xff;
2178 digest
[26] = (l
>> 16) & 0xff;
2180 l
= itoa64_to_int (buf
[36]) << 0;
2181 l
|= itoa64_to_int (buf
[37]) << 6;
2182 l
|= itoa64_to_int (buf
[38]) << 12;
2183 l
|= itoa64_to_int (buf
[39]) << 18;
2185 digest
[27] = (l
>> 0) & 0xff;
2186 digest
[28] = (l
>> 8) & 0xff;
2187 digest
[29] = (l
>> 16) & 0xff;
2189 l
= itoa64_to_int (buf
[40]) << 0;
2190 l
|= itoa64_to_int (buf
[41]) << 6;
2191 l
|= itoa64_to_int (buf
[42]) << 12;
2192 l
|= itoa64_to_int (buf
[43]) << 18;
2194 digest
[30] = (l
>> 0) & 0xff;
2195 digest
[31] = (l
>> 8) & 0xff;
2196 digest
[32] = (l
>> 16) & 0xff;
2231 void drupal7_encode (unsigned char digest
[64], unsigned char buf
[43])
2235 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2237 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2238 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2239 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2240 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2242 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2244 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2249 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2251 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[11] = int_to_itoa64 (l
& 0x3f);
2256 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2258 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[15] = int_to_itoa64 (l
& 0x3f);
2263 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2265 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[19] = int_to_itoa64 (l
& 0x3f);
2270 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2272 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[23] = int_to_itoa64 (l
& 0x3f);
2277 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2279 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[27] = int_to_itoa64 (l
& 0x3f);
2284 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2286 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[31] = int_to_itoa64 (l
& 0x3f);
2291 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2293 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[35] = int_to_itoa64 (l
& 0x3f);
2298 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2300 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[39] = int_to_itoa64 (l
& 0x3f);
2305 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2307 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 //buf[43] = int_to_itoa64 (l & 0x3f);
2318 static struct termio savemodes
;
2319 static int havemodes
= 0;
2323 struct termio modmodes
;
2325 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2329 modmodes
= savemodes
;
2330 modmodes
.c_lflag
&= ~ICANON
;
2331 modmodes
.c_cc
[VMIN
] = 1;
2332 modmodes
.c_cc
[VTIME
] = 0;
2334 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2343 FD_SET (fileno (stdin
), &rfds
);
2350 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2352 if (retval
== 0) return 0;
2353 if (retval
== -1) return -1;
2360 if (!havemodes
) return 0;
2362 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2367 static struct termios savemodes
;
2368 static int havemodes
= 0;
2372 struct termios modmodes
;
2374 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2378 modmodes
= savemodes
;
2379 modmodes
.c_lflag
&= ~ICANON
;
2380 modmodes
.c_cc
[VMIN
] = 1;
2381 modmodes
.c_cc
[VTIME
] = 0;
2383 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2392 FD_SET (fileno (stdin
), &rfds
);
2399 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2401 if (retval
== 0) return 0;
2402 if (retval
== -1) return -1;
2409 if (!havemodes
) return 0;
2411 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2416 static DWORD saveMode
= 0;
2420 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2422 GetConsoleMode (stdinHandle
, &saveMode
);
2423 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2430 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2432 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2434 if (rc
== WAIT_TIMEOUT
) return 0;
2435 if (rc
== WAIT_ABANDONED
) return -1;
2436 if (rc
== WAIT_FAILED
) return -1;
2438 // The whole ReadConsoleInput () part is a workaround.
2439 // For some unknown reason, maybe a mingw bug, a random signal
2440 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2441 // Then it wants to read with getche () a keyboard input
2442 // which has never been made.
2444 INPUT_RECORD buf
[100];
2448 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2450 FlushConsoleInputBuffer (stdinHandle
);
2452 for (uint i
= 0; i
< num
; i
++)
2454 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2456 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2458 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2460 return KeyEvent
.uChar
.AsciiChar
;
2468 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2470 SetConsoleMode (stdinHandle
, saveMode
);
2480 #define MSG_ENOMEM "Insufficient memory available"
2482 void *mycalloc (size_t nmemb
, size_t size
)
2484 void *p
= calloc (nmemb
, size
);
2488 log_error ("ERROR: %s", MSG_ENOMEM
);
2496 void *mymalloc (size_t size
)
2498 void *p
= malloc (size
);
2502 log_error ("ERROR: %s", MSG_ENOMEM
);
2507 memset (p
, 0, size
);
2512 void myfree (void *ptr
)
2514 if (ptr
== NULL
) return;
2519 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2521 void *p
= realloc (ptr
, oldsz
+ add
);
2525 log_error ("ERROR: %s", MSG_ENOMEM
);
2530 memset ((char *) p
+ oldsz
, 0, add
);
2535 char *mystrdup (const char *s
)
2537 const size_t len
= strlen (s
);
2539 char *b
= (char *) mymalloc (len
+ 1);
2546 FILE *logfile_open (char *logfile
)
2548 FILE *fp
= fopen (logfile
, "ab");
2558 void logfile_close (FILE *fp
)
2560 if (fp
== stdout
) return;
2565 void logfile_append (const char *fmt
, ...)
2567 if (data
.logfile_disable
== 1) return;
2569 FILE *fp
= logfile_open (data
.logfile
);
2575 vfprintf (fp
, fmt
, ap
);
2586 int logfile_generate_id ()
2588 const int n
= rand ();
2597 char *logfile_generate_topid ()
2599 const int id
= logfile_generate_id ();
2601 char *topid
= (char *) mymalloc (1 + 16 + 1);
2603 sprintf (topid
, "TOP%08x", id
);
2608 char *logfile_generate_subid ()
2610 const int id
= logfile_generate_id ();
2612 char *subid
= (char *) mymalloc (1 + 16 + 1);
2614 sprintf (subid
, "SUB%08x", id
);
2626 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2628 FlushFileBuffers (h
);
2637 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2641 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2645 log_info ("WARN: No NvAPI adapters found");
2655 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2659 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2661 // do not use wrapper function to omit warning message
2662 if (nvmlDeviceGetHandleByIndex (i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2664 //can be used to determine if the device by index matches the cuda device by index
2665 //char name[100]; memset (name, 0, sizeof (name));
2666 //hc_NVML_nvmlDeviceGetName (nvGPUHandle[i], name, sizeof (name) - 1);
2673 log_info ("WARN: No NVML adapters found");
2682 void hm_close_amd (HM_LIB hm_dll
)
2688 FreeLibrary (hm_dll
);
2693 HM_LIB
hm_init_amd ()
2696 HM_LIB hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2699 HM_LIB hm_dll
= LoadLibrary ("atiadlxx.dll");
2702 hm_dll
= LoadLibrary ("atiadlxy.dll");
2709 int get_adapters_num_amd (HM_LIB hm_dll
, int *iNumberAdapters
)
2711 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll
, iNumberAdapters
) != ADL_OK
) return -1;
2713 if (iNumberAdapters
== 0)
2715 log_info ("WARN: No ADL adapters found.");
2724 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2726 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2727 ADLODParameters lpOdParameters;
2729 lpOdParameters.iSize = sizeof (ADLODParameters);
2730 size_t plevels_size = 0;
2732 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2734 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2735 __func__, iAdapterIndex,
2736 lpOdParameters.iNumberOfPerformanceLevels,
2737 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2738 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2740 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2742 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2744 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2746 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2748 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2749 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2750 __func__, iAdapterIndex, j,
2751 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2753 myfree (lpOdPerformanceLevels);
2759 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll
, int iNumberAdapters
)
2761 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2763 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2765 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2767 return lpAdapterInfo
;
2772 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2775 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2779 for (uint i = 0; i < num_adl_adapters; i++)
2781 int opencl_bus_num = hm_device[i].busid;
2782 int opencl_dev_num = hm_device[i].devid;
2784 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2792 if (idx >= DEVICES_MAX) return -1;
2797 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2799 for (uint i = 0; i < opencl_num_devices; i++)
2801 cl_device_topology_amd device_topology;
2803 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2805 hm_device[i].busid = device_topology.pcie.bus;
2806 hm_device[i].devid = device_topology.pcie.device;
2811 void hm_sort_adl_adapters_by_busid_devid (uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2813 // basically bubble sort
2815 for (int i
= 0; i
< num_adl_adapters
; i
++)
2817 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2819 // get info of adapter [x]
2821 uint32_t adapter_index_x
= valid_adl_device_list
[j
];
2822 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2824 uint32_t bus_num_x
= info_x
.iBusNumber
;
2825 uint32_t dev_num_x
= info_x
.iDeviceNumber
;
2827 // get info of adapter [y]
2829 uint32_t adapter_index_y
= valid_adl_device_list
[j
+ 1];
2830 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2832 uint32_t bus_num_y
= info_y
.iBusNumber
;
2833 uint32_t dev_num_y
= info_y
.iDeviceNumber
;
2837 if (bus_num_y
< bus_num_x
)
2841 else if (bus_num_y
== bus_num_x
)
2843 if (dev_num_y
< dev_num_x
)
2851 uint32_t temp
= valid_adl_device_list
[j
+ 1];
2853 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2854 valid_adl_device_list
[j
+ 0] = temp
;
2860 uint32_t *hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2862 *num_adl_adapters
= 0;
2864 uint32_t *adl_adapters
= NULL
;
2866 int *bus_numbers
= NULL
;
2867 int *device_numbers
= NULL
;
2869 for (int i
= 0; i
< iNumberAdapters
; i
++)
2871 AdapterInfo info
= lpAdapterInfo
[i
];
2873 if ((info
.strUDID
== NULL
) || (strlen (info
.strUDID
) < 1)) continue;
2876 if (info
.iVendorID
!= 1002) continue;
2878 if (info
.iVendorID
!= 0x1002) continue;
2881 if (info
.iBusNumber
< 0) continue;
2882 if (info
.iDeviceNumber
< 0) continue;
2886 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2888 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2895 if (found
) continue;
2897 // add it to the list
2899 adl_adapters
= (uint32_t *) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2901 adl_adapters
[*num_adl_adapters
] = i
;
2903 // rest is just bookkeeping
2905 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2906 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2908 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2909 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2911 (*num_adl_adapters
)++;
2914 myfree (bus_numbers
);
2915 myfree (device_numbers
);
2917 // sort the list by increasing bus id, device id number
2919 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2921 return adl_adapters
;
2924 int hm_check_fanspeed_control (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2926 // loop through all valid devices
2928 for (int i
= 0; i
< num_adl_adapters
; i
++)
2930 uint32_t adapter_index
= valid_adl_device_list
[i
];
2934 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2936 // unfortunately this doesn't work since bus id and dev id are not unique
2937 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2938 // if (opencl_device_index == -1) continue;
2940 int opencl_device_index
= i
;
2942 // if (hm_show_performance_level (hm_dll, info.iAdapterIndex) != 0) return -1;
2944 // get fanspeed info
2946 if (hm_device
[opencl_device_index
].od_version
== 5)
2948 ADLFanSpeedInfo FanSpeedInfo
;
2950 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2952 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2954 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2956 // check read and write capability in fanspeedinfo
2958 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2959 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2961 hm_device
[opencl_device_index
].fan_supported
= 1;
2965 hm_device
[opencl_device_index
].fan_supported
= 0;
2968 else // od_version == 6
2970 ADLOD6FanSpeedInfo faninfo
;
2972 memset (&faninfo
, 0, sizeof (faninfo
));
2974 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2976 // check read capability in fanspeedinfo
2978 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2980 hm_device
[opencl_device_index
].fan_supported
= 1;
2984 hm_device
[opencl_device_index
].fan_supported
= 0;
2992 int hm_get_overdrive_version (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2994 for (int i
= 0; i
< num_adl_adapters
; i
++)
2996 uint32_t adapter_index
= valid_adl_device_list
[i
];
3000 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3002 // get overdrive version
3004 int od_supported
= 0;
3008 if (hc_ADL_Overdrive_Caps (hm_dll
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3010 // store the overdrive version in hm_device
3012 // unfortunately this doesn't work since bus id and dev id are not unique
3013 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3014 // if (opencl_device_index == -1) continue;
3016 int opencl_device_index
= i
;
3018 hm_device
[opencl_device_index
].od_version
= od_version
;
3024 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3026 for (int i
= 0; i
< num_adl_adapters
; i
++)
3028 uint32_t adapter_index
= valid_adl_device_list
[i
];
3032 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3034 // store the iAdapterIndex in hm_device
3036 // unfortunately this doesn't work since bus id and dev id are not unique
3037 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3038 // if (opencl_device_index == -1) continue;
3040 int opencl_device_index
= i
;
3042 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3045 return num_adl_adapters
;
3048 int hm_get_temperature_with_device_id (const uint device_id
)
3050 if (data
.vendor_id
== VENDOR_ID_AMD
)
3054 if (data
.hm_device
[device_id
].od_version
== 5)
3056 ADLTemperature Temperature
;
3058 Temperature
.iSize
= sizeof (ADLTemperature
);
3060 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3062 return Temperature
.iTemperature
/ 1000;
3064 else if (data
.hm_device
[device_id
].od_version
== 6)
3066 int Temperature
= 0;
3068 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3070 return Temperature
/ 1000;
3075 if (data
.vendor_id
== VENDOR_ID_NV
)
3078 int temperature
= 0;
3080 hc_NVML_nvmlDeviceGetTemperature (data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3086 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3088 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3089 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3090 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3091 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3093 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3095 return pThermalSettings
.sensor
[0].currentTemp
;
3102 int hm_get_fanspeed_with_device_id (const uint device_id
)
3104 if (data
.hm_device
[device_id
].fan_supported
== 1)
3106 if (data
.vendor_id
== VENDOR_ID_AMD
)
3110 if (data
.hm_device
[device_id
].od_version
== 5)
3112 ADLFanSpeedValue lpFanSpeedValue
;
3114 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3116 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3117 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3118 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3120 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3122 return lpFanSpeedValue
.iFanSpeed
;
3124 else // od_version == 6
3126 ADLOD6FanSpeedInfo faninfo
;
3128 memset (&faninfo
, 0, sizeof (faninfo
));
3130 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3132 return faninfo
.iFanSpeedPercent
;
3137 if (data
.vendor_id
== VENDOR_ID_NV
)
3142 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3150 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3160 int hm_get_utilization_with_device_id (const uint device_id
)
3162 if (data
.vendor_id
== VENDOR_ID_AMD
)
3166 ADLPMActivity PMActivity
;
3168 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3170 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3172 return PMActivity
.iActivityPercent
;
3176 if (data
.vendor_id
== VENDOR_ID_NV
)
3179 nvmlUtilization_t utilization
;
3181 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3183 return utilization
.gpu
;
3187 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3189 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3191 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3193 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3200 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3202 if (data
.hm_device
[device_id
].fan_supported
== 1)
3206 if (data
.hm_device
[device_id
].od_version
== 5)
3208 ADLFanSpeedValue lpFanSpeedValue
;
3210 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3212 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3213 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3214 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3215 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3217 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3221 else // od_version == 6
3223 ADLOD6FanSpeedValue fan_speed_value
;
3225 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3227 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3228 fan_speed_value
.iFanSpeed
= fanspeed
;
3230 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3244 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3246 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3248 if (css_cnt
> SP_PW_MAX
)
3250 log_error ("ERROR: mask length is too long");
3255 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3257 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3259 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3260 uint cs_len
= css
[css_pos
].cs_len
;
3262 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3264 uint c
= cs_buf
[cs_pos
] & 0xff;
3271 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3273 cs_t
*cs
= &css
[css_cnt
];
3275 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3277 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3279 memset (css_uniq
, 0, css_uniq_sz
);
3283 for (i
= 0; i
< cs
->cs_len
; i
++)
3285 const uint u
= cs
->cs_buf
[i
];
3290 for (i
= 0; i
< in_len
; i
++)
3292 uint u
= in_buf
[i
] & 0xff;
3294 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3296 if (css_uniq
[u
] == 1) continue;
3300 cs
->cs_buf
[cs
->cs_len
] = u
;
3308 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3312 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3314 uint p0
= in_buf
[in_pos
] & 0xff;
3316 if (interpret
== 1 && p0
== '?')
3320 if (in_pos
== in_len
) break;
3322 uint p1
= in_buf
[in_pos
] & 0xff;
3326 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3328 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3330 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3332 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3334 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3336 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3338 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3339 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3341 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3342 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3344 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3345 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3347 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3348 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3350 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3352 default: log_error ("Syntax error: %s", in_buf
);
3358 if (data
.hex_charset
)
3362 if (in_pos
== in_len
)
3364 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3369 uint p1
= in_buf
[in_pos
] & 0xff;
3371 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3373 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3380 chr
= hex_convert (p1
) << 0;
3381 chr
|= hex_convert (p0
) << 4;
3383 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3389 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3395 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3399 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3401 sum
*= css
[css_pos
].cs_len
;
3407 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3409 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3414 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3416 char p0
= mask_buf
[mask_pos
];
3422 if (mask_pos
== mask_len
) break;
3424 char p1
= mask_buf
[mask_pos
];
3430 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3432 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3434 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3436 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3438 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3440 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3442 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3443 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3445 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3446 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3448 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3449 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3451 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3452 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3454 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3456 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3462 if (data
.hex_charset
)
3466 // if there is no 2nd hex character, show an error:
3468 if (mask_pos
== mask_len
)
3470 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3475 char p1
= mask_buf
[mask_pos
];
3477 // if they are not valid hex character, show an error:
3479 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3481 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3488 chr
|= hex_convert (p1
) << 0;
3489 chr
|= hex_convert (p0
) << 4;
3491 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3497 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3504 log_error ("ERROR: invalid mask length (0)");
3514 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3516 for (int i
= 0; i
< css_cnt
; i
++)
3518 uint len
= css
[i
].cs_len
;
3519 uint64_t next
= val
/ len
;
3520 uint pos
= val
% len
;
3521 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3526 void mp_cut_at (char *mask
, uint max
)
3530 uint mask_len
= strlen (mask
);
3532 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3534 if (mask
[i
] == '?') i
++;
3540 void mp_setup_sys (cs_t
*mp_sys
)
3544 uint donec
[CHARSIZ
];
3546 memset (donec
, 0, sizeof (donec
));
3548 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3549 mp_sys
[0].cs_buf
[pos
++] = chr
;
3550 mp_sys
[0].cs_len
= pos
; }
3552 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3553 mp_sys
[1].cs_buf
[pos
++] = chr
;
3554 mp_sys
[1].cs_len
= pos
; }
3556 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3557 mp_sys
[2].cs_buf
[pos
++] = chr
;
3558 mp_sys
[2].cs_len
= pos
; }
3560 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3561 mp_sys
[3].cs_buf
[pos
++] = chr
;
3562 mp_sys
[3].cs_len
= pos
; }
3564 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3565 mp_sys
[4].cs_len
= pos
; }
3567 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3568 mp_sys
[5].cs_len
= pos
; }
3571 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3573 FILE *fp
= fopen (buf
, "rb");
3575 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3577 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3583 memset (mp_file
, 0, sizeof (mp_file
));
3585 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3589 len
= in_superchop (mp_file
);
3593 log_info ("WARNING: charset file corrupted");
3595 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3599 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3604 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3606 mp_usr
[index
].cs_len
= 0;
3608 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3611 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3613 char *new_mask_buf
= (char *) mymalloc (256);
3619 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3621 if (css_pos
== len
) break;
3623 char p0
= mask_buf
[mask_pos
];
3625 new_mask_buf
[mask_pos
] = p0
;
3631 if (mask_pos
== mask_len
) break;
3633 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3637 if (data
.hex_charset
)
3641 if (mask_pos
== mask_len
)
3643 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3648 char p1
= mask_buf
[mask_pos
];
3650 // if they are not valid hex character, show an error:
3652 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3654 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3659 new_mask_buf
[mask_pos
] = p1
;
3664 if (css_pos
== len
) return (new_mask_buf
);
3666 myfree (new_mask_buf
);
3675 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3681 for (i
= start
; i
< stop
; i
++)
3683 sum
*= root_css_buf
[i
].cs_len
;
3689 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3693 cs_t
*cs
= &root_css_buf
[start
];
3697 for (i
= start
; i
< stop
; i
++)
3699 const uint64_t m
= v
% cs
->cs_len
;
3700 const uint64_t d
= v
/ cs
->cs_len
;
3704 const uint k
= cs
->cs_buf
[m
];
3706 pw_buf
[i
- start
] = (char) k
;
3708 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3712 int sp_comp_val (const void *p1
, const void *p2
)
3714 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3715 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3717 return b2
->val
- b1
->val
;
3720 void sp_setup_tbl (const char *install_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3727 * Initialize hcstats
3730 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3732 uint64_t *root_stats_ptr
= root_stats_buf
;
3734 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3736 for (i
= 0; i
< SP_PW_MAX
; i
++)
3738 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3740 root_stats_ptr
+= CHARSIZ
;
3743 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3745 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3747 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3749 for (i
= 0; i
< SP_PW_MAX
; i
++)
3751 for (j
= 0; j
< CHARSIZ
; j
++)
3753 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3755 markov_stats_ptr
+= CHARSIZ
;
3765 char hcstat_tmp
[256];
3767 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3769 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", install_dir
, SP_HCSTAT
);
3771 hcstat
= hcstat_tmp
;
3774 FILE *fd
= fopen (hcstat
, "rb");
3778 log_error ("%s: %s", hcstat
, strerror (errno
));
3783 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3785 log_error ("%s: Could not load data", hcstat
);
3790 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3792 log_error ("%s: Could not load data", hcstat
);
3800 * Markov modifier of hcstat_table on user request
3805 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3806 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3811 /* Add all stats to first position */
3813 for (i
= 1; i
< SP_PW_MAX
; i
++)
3815 uint64_t *out
= root_stats_buf_by_pos
[0];
3816 uint64_t *in
= root_stats_buf_by_pos
[i
];
3818 for (j
= 0; j
< CHARSIZ
; j
++)
3824 for (i
= 1; i
< SP_PW_MAX
; i
++)
3826 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3827 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3829 for (j
= 0; j
< CHARSIZ
; j
++)
3831 for (k
= 0; k
< CHARSIZ
; k
++)
3838 /* copy them to all pw_positions */
3840 for (i
= 1; i
< SP_PW_MAX
; i
++)
3842 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3845 for (i
= 1; i
< SP_PW_MAX
; i
++)
3847 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3855 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3857 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3859 for (i
= 0; i
< SP_PW_MAX
; i
++)
3861 root_table_buf_by_pos
[i
] = root_table_ptr
;
3863 root_table_ptr
+= CHARSIZ
;
3866 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3868 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3870 for (i
= 0; i
< SP_PW_MAX
; i
++)
3872 for (j
= 0; j
< CHARSIZ
; j
++)
3874 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3876 markov_table_ptr
+= CHARSIZ
;
3881 * Convert hcstat to tables
3884 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3886 uint key
= i
% CHARSIZ
;
3888 root_table_buf
[i
].key
= key
;
3889 root_table_buf
[i
].val
= root_stats_buf
[i
];
3892 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3894 uint key
= i
% CHARSIZ
;
3896 markov_table_buf
[i
].key
= key
;
3897 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3900 myfree (root_stats_buf
);
3901 myfree (markov_stats_buf
);
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3912 for (i
= 0; i
< SP_PW_MAX
; i
++)
3914 for (j
= 0; j
< CHARSIZ
; j
++)
3916 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3921 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
])
3924 * Convert tables to css
3927 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3929 uint pw_pos
= i
/ CHARSIZ
;
3931 cs_t
*cs
= &root_css_buf
[pw_pos
];
3933 if (cs
->cs_len
== threshold
) continue;
3935 uint key
= root_table_buf
[i
].key
;
3937 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3939 cs
->cs_buf
[cs
->cs_len
] = key
;
3945 * Convert table to css
3948 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3950 uint c
= i
/ CHARSIZ
;
3952 cs_t
*cs
= &markov_css_buf
[c
];
3954 if (cs
->cs_len
== threshold
) continue;
3956 uint pw_pos
= c
/ CHARSIZ
;
3958 uint key
= markov_table_buf
[i
].key
;
3960 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3962 cs
->cs_buf
[cs
->cs_len
] = key
;
3968 for (uint i = 0; i < 8; i++)
3970 for (uint j = 0x20; j < 0x80; j++)
3972 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
3974 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
3976 for (uint k = 0; k < 10; k++)
3978 printf (" %u\n", ptr->cs_buf[k]);
3985 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
3987 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
3989 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
3999 for (uint j
= 1; j
< CHARSIZ
; j
++)
4009 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4011 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4013 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4015 out
+= CHARSIZ
* CHARSIZ
;
4016 in
+= CHARSIZ
* CHARSIZ
;
4018 for (uint j
= 0; j
< CHARSIZ
; j
++)
4025 for (uint k
= 1; k
< CHARSIZ
; k
++)
4037 * mixed shared functions
4040 void dump_hex (const char *s
, size_t size
)
4044 for (i
= 0; i
< size
; i
++)
4046 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4052 void usage_mini_print (const char *progname
)
4054 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4057 void usage_big_print (const char *progname
)
4059 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4062 char *get_install_dir (const char *progname
)
4064 char *install_dir
= mystrdup (progname
);
4065 char *last_slash
= NULL
;
4067 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4071 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4077 install_dir
[0] = '.';
4081 return (install_dir
);
4084 char *get_profile_dir (const char *homedir
)
4086 #define DOT_HASHCAT ".hashcat"
4088 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4090 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4095 char *get_session_dir (const char *profile_dir
, const char *session
)
4097 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (session
) + 1);
4099 sprintf (session_dir
, "%s/%s", profile_dir
, session
);
4104 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4108 FILE *fd
= fopen (file
, "rb");
4112 log_error ("%s: %s", file
, strerror (errno
));
4117 #define MAX_KEY_SIZE (1024 * 1024)
4119 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4121 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4125 for (int fpos
= 0; fpos
< nread
; fpos
++)
4127 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4129 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4130 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4131 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4132 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4134 if (kpos
>= 64) kpos
= 0;
4142 void set_cpu_affinity (char *cpu_affinity
)
4145 DWORD_PTR aff_mask
= 0;
4156 char *devices
= strdup (cpu_affinity
);
4158 char *next
= strtok (devices
, ",");
4162 uint cpu_id
= atoi (next
);
4179 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4185 aff_mask
|= 1 << (cpu_id
- 1);
4189 CPU_SET ((cpu_id
- 1), &cpuset
);
4192 } while ((next
= strtok (NULL
, ",")) != NULL
);
4198 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4199 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4203 pthread_t thread
= pthread_self ();
4204 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4208 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4210 char *element
, *end
;
4212 end
= (char *) base
+ nmemb
* size
;
4214 for (element
= (char *) base
; element
< end
; element
+= size
)
4215 if (!compar (element
, key
))
4221 int sort_by_salt (const void *v1
, const void *v2
)
4223 const salt_t
*s1
= (const salt_t
*) v1
;
4224 const salt_t
*s2
= (const salt_t
*) v2
;
4226 const int res1
= s1
->salt_len
- s2
->salt_len
;
4228 if (res1
!= 0) return (res1
);
4230 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4232 if (res2
!= 0) return (res2
);
4240 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4241 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4248 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4249 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4255 int sort_by_salt_buf (const void *v1
, const void *v2
)
4257 const pot_t
*p1
= (const pot_t
*) v1
;
4258 const pot_t
*p2
= (const pot_t
*) v2
;
4260 const hash_t
*h1
= &p1
->hash
;
4261 const hash_t
*h2
= &p2
->hash
;
4263 const salt_t
*s1
= h1
->salt
;
4264 const salt_t
*s2
= h2
->salt
;
4270 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4271 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4277 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4279 const hash_t
*h1
= (const hash_t
*) v1
;
4280 const hash_t
*h2
= (const hash_t
*) v2
;
4282 const salt_t
*s1
= h1
->salt
;
4283 const salt_t
*s2
= h2
->salt
;
4285 // testphase: this should work
4290 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4291 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4294 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4295 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4296 if (s1->salt_len > s2->salt_len) return ( 1);
4297 if (s1->salt_len < s2->salt_len) return (-1);
4299 uint n = s1->salt_len;
4303 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4304 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4311 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4313 const hash_t
*h1
= (const hash_t
*) v1
;
4314 const hash_t
*h2
= (const hash_t
*) v2
;
4316 const salt_t
*s1
= h1
->salt
;
4317 const salt_t
*s2
= h2
->salt
;
4319 // 12 - 2 (since last 2 uints contain the digest)
4324 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4325 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4331 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4333 const hash_t
*h1
= (const hash_t
*) v1
;
4334 const hash_t
*h2
= (const hash_t
*) v2
;
4336 const void *d1
= h1
->digest
;
4337 const void *d2
= h2
->digest
;
4339 return data
.sort_by_digest (d1
, d2
);
4342 int sort_by_hash (const void *v1
, const void *v2
)
4344 const hash_t
*h1
= (const hash_t
*) v1
;
4345 const hash_t
*h2
= (const hash_t
*) v2
;
4349 const salt_t
*s1
= h1
->salt
;
4350 const salt_t
*s2
= h2
->salt
;
4352 int res
= sort_by_salt (s1
, s2
);
4354 if (res
!= 0) return (res
);
4357 const void *d1
= h1
->digest
;
4358 const void *d2
= h2
->digest
;
4360 return data
.sort_by_digest (d1
, d2
);
4363 int sort_by_pot (const void *v1
, const void *v2
)
4365 const pot_t
*p1
= (const pot_t
*) v1
;
4366 const pot_t
*p2
= (const pot_t
*) v2
;
4368 const hash_t
*h1
= &p1
->hash
;
4369 const hash_t
*h2
= &p2
->hash
;
4371 return sort_by_hash (h1
, h2
);
4374 int sort_by_mtime (const void *p1
, const void *p2
)
4376 const char **f1
= (const char **) p1
;
4377 const char **f2
= (const char **) p2
;
4379 struct stat s1
; stat (*f1
, &s1
);
4380 struct stat s2
; stat (*f2
, &s2
);
4382 return s2
.st_mtime
- s1
.st_mtime
;
4385 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4387 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4388 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4390 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4393 int sort_by_gpu_rule (const void *p1
, const void *p2
)
4395 const gpu_rule_t
*r1
= (const gpu_rule_t
*) p1
;
4396 const gpu_rule_t
*r2
= (const gpu_rule_t
*) p2
;
4398 return memcmp (r1
, r2
, sizeof (gpu_rule_t
));
4401 int sort_by_stringptr (const void *p1
, const void *p2
)
4403 const char **s1
= (const char **) p1
;
4404 const char **s2
= (const char **) p2
;
4406 return strcmp (*s1
, *s2
);
4409 int sort_by_dictstat (const void *s1
, const void *s2
)
4411 dictstat_t
*d1
= (dictstat_t
*) s1
;
4412 dictstat_t
*d2
= (dictstat_t
*) s2
;
4415 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4417 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4420 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4423 int sort_by_bitmap (const void *p1
, const void *p2
)
4425 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4426 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4428 return b1
->collisions
- b2
->collisions
;
4431 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4433 const uint32_t *d1
= (const uint32_t *) v1
;
4434 const uint32_t *d2
= (const uint32_t *) v2
;
4440 if (d1
[n
] > d2
[n
]) return ( 1);
4441 if (d1
[n
] < d2
[n
]) return (-1);
4447 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4449 const uint32_t *d1
= (const uint32_t *) v1
;
4450 const uint32_t *d2
= (const uint32_t *) v2
;
4456 if (d1
[n
] > d2
[n
]) return ( 1);
4457 if (d1
[n
] < d2
[n
]) return (-1);
4463 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4465 const uint32_t *d1
= (const uint32_t *) v1
;
4466 const uint32_t *d2
= (const uint32_t *) v2
;
4472 if (d1
[n
] > d2
[n
]) return ( 1);
4473 if (d1
[n
] < d2
[n
]) return (-1);
4479 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4481 const uint32_t *d1
= (const uint32_t *) v1
;
4482 const uint32_t *d2
= (const uint32_t *) v2
;
4488 if (d1
[n
] > d2
[n
]) return ( 1);
4489 if (d1
[n
] < d2
[n
]) return (-1);
4495 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4497 const uint32_t *d1
= (const uint32_t *) v1
;
4498 const uint32_t *d2
= (const uint32_t *) v2
;
4504 if (d1
[n
] > d2
[n
]) return ( 1);
4505 if (d1
[n
] < d2
[n
]) return (-1);
4511 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4513 const uint32_t *d1
= (const uint32_t *) v1
;
4514 const uint32_t *d2
= (const uint32_t *) v2
;
4520 if (d1
[n
] > d2
[n
]) return ( 1);
4521 if (d1
[n
] < d2
[n
]) return (-1);
4527 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4529 const uint32_t *d1
= (const uint32_t *) v1
;
4530 const uint32_t *d2
= (const uint32_t *) v2
;
4536 if (d1
[n
] > d2
[n
]) return ( 1);
4537 if (d1
[n
] < d2
[n
]) return (-1);
4543 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4545 const uint32_t *d1
= (const uint32_t *) v1
;
4546 const uint32_t *d2
= (const uint32_t *) v2
;
4552 if (d1
[n
] > d2
[n
]) return ( 1);
4553 if (d1
[n
] < d2
[n
]) return (-1);
4559 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4561 const uint64_t *d1
= (const uint64_t *) v1
;
4562 const uint64_t *d2
= (const uint64_t *) v2
;
4568 if (d1
[n
] > d2
[n
]) return ( 1);
4569 if (d1
[n
] < d2
[n
]) return (-1);
4575 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4577 const uint64_t *d1
= (const uint64_t *) v1
;
4578 const uint64_t *d2
= (const uint64_t *) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4593 const uint64_t *d1
= (const uint64_t *) v1
;
4594 const uint64_t *d2
= (const uint64_t *) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4609 const uint32_t *d1
= (const uint32_t *) v1
;
4610 const uint32_t *d2
= (const uint32_t *) v2
;
4612 const uint dgst_pos0
= data
.dgst_pos0
;
4613 const uint dgst_pos1
= data
.dgst_pos1
;
4614 const uint dgst_pos2
= data
.dgst_pos2
;
4615 const uint dgst_pos3
= data
.dgst_pos3
;
4617 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4618 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4619 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4620 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4621 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4622 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4623 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4624 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4629 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
)
4631 uint outfile_autohex
= data
.outfile_autohex
;
4633 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4635 FILE *debug_fp
= NULL
;
4637 if (debug_file
!= NULL
)
4639 debug_fp
= fopen (debug_file
, "ab");
4646 if (debug_fp
== NULL
)
4648 log_info ("WARNING: Could not open debug-file for writing");
4652 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4654 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4656 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4659 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4661 if (debug_mode
== 4)
4663 fputc (':', debug_fp
);
4665 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4668 fputc ('\n', debug_fp
);
4670 if (debug_file
!= NULL
) fclose (debug_fp
);
4674 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4676 int needs_hexify
= 0;
4678 if (outfile_autohex
== 1)
4680 for (uint i
= 0; i
< plain_len
; i
++)
4682 if (plain_ptr
[i
] < 0x20)
4689 if (plain_ptr
[i
] > 0x7f)
4698 if (needs_hexify
== 1)
4700 fprintf (fp
, "$HEX[");
4702 for (uint i
= 0; i
< plain_len
; i
++)
4704 fprintf (fp
, "%02x", plain_ptr
[i
]);
4711 fwrite (plain_ptr
, plain_len
, 1, fp
);
4715 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const uint64_t crackpos
, unsigned char *username
, const uint user_len
)
4717 uint outfile_format
= data
.outfile_format
;
4719 char separator
= data
.separator
;
4721 if (outfile_format
& OUTFILE_FMT_HASH
)
4723 fprintf (out_fp
, "%s", out_buf
);
4725 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4727 fputc (separator
, out_fp
);
4730 else if (data
.username
)
4732 if (username
!= NULL
)
4734 for (uint i
= 0; i
< user_len
; i
++)
4736 fprintf (out_fp
, "%c", username
[i
]);
4739 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4741 fputc (separator
, out_fp
);
4746 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4748 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4750 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4752 fputc (separator
, out_fp
);
4756 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4758 for (uint i
= 0; i
< plain_len
; i
++)
4760 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4763 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4765 fputc (separator
, out_fp
);
4769 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4772 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4777 fprintf (out_fp
, "%lu", crackpos
);
4779 fprintf (out_fp
, "%llu", crackpos
);
4784 fputc ('\n', out_fp
);
4787 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
)
4791 pot_key
.hash
.salt
= hashes_buf
->salt
;
4792 pot_key
.hash
.digest
= hashes_buf
->digest
;
4794 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4800 input_buf
[input_len
] = 0;
4803 unsigned char *username
= NULL
;
4808 user_t
*user
= hashes_buf
->hash_info
->user
;
4812 username
= (unsigned char *) (user
->user_name
);
4814 user_len
= user
->user_len
;
4818 // do output the line
4819 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4823 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4824 #define LM_MASKED_PLAIN "[notfound]"
4826 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
)
4832 pot_left_key
.hash
.salt
= hash_left
->salt
;
4833 pot_left_key
.hash
.digest
= hash_left
->digest
;
4835 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4839 uint weak_hash_found
= 0;
4841 pot_t pot_right_key
;
4843 pot_right_key
.hash
.salt
= hash_right
->salt
;
4844 pot_right_key
.hash
.digest
= hash_right
->digest
;
4846 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4848 if (pot_right_ptr
== NULL
)
4850 // special case, if "weak hash"
4852 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4854 weak_hash_found
= 1;
4856 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4858 // in theory this is not needed, but we are paranoia:
4860 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4861 pot_right_ptr
->plain_len
= 0;
4865 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4867 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
4872 // at least one half was found:
4876 input_buf
[input_len
] = 0;
4880 unsigned char *username
= NULL
;
4885 user_t
*user
= hash_left
->hash_info
->user
;
4889 username
= (unsigned char *) (user
->user_name
);
4891 user_len
= user
->user_len
;
4895 // mask the part which was not found
4897 uint left_part_masked
= 0;
4898 uint right_part_masked
= 0;
4900 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4902 if (pot_left_ptr
== NULL
)
4904 left_part_masked
= 1;
4906 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4908 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4910 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4911 pot_left_ptr
->plain_len
= mask_plain_len
;
4914 if (pot_right_ptr
== NULL
)
4916 right_part_masked
= 1;
4918 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4920 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4922 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4923 pot_right_ptr
->plain_len
= mask_plain_len
;
4926 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4930 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4932 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4934 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4936 // do output the line
4938 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4940 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4942 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4943 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4946 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
)
4950 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4952 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4954 if (pot_ptr
== NULL
)
4958 input_buf
[input_len
] = 0;
4960 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
4964 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
)
4970 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
4972 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4976 pot_t pot_right_key
;
4978 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
4980 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4982 uint weak_hash_found
= 0;
4984 if (pot_right_ptr
== NULL
)
4986 // special case, if "weak hash"
4988 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4990 weak_hash_found
= 1;
4992 // we just need that pot_right_ptr is not a NULL pointer
4994 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4998 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5000 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5005 // ... at least one part was not cracked
5009 input_buf
[input_len
] = 0;
5011 // only show the hash part which is still not cracked
5013 uint user_len
= input_len
- 32;
5015 char hash_output
[user_len
+ 33];
5017 memset (hash_output
, 0, sizeof (hash_output
));
5019 memcpy (hash_output
, input_buf
, input_len
);
5021 if (pot_left_ptr
!= NULL
)
5023 // only show right part (because left part was already found)
5025 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5027 hash_output
[user_len
+ 16] = 0;
5030 if (pot_right_ptr
!= NULL
)
5032 // only show left part (because right part was already found)
5034 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5036 hash_output
[user_len
+ 16] = 0;
5039 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5041 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5044 uint
devices_to_devicemask (char *gpu_devices
)
5046 uint gpu_devicemask
= 0;
5050 char *devices
= strdup (gpu_devices
);
5052 char *next
= strtok (devices
, ",");
5056 uint gpu_id
= atoi (next
);
5058 if (gpu_id
< 1 || gpu_id
> 8)
5060 log_error ("ERROR: invalid gpu_id %u specified", gpu_id
);
5065 gpu_devicemask
|= 1 << (gpu_id
- 1);
5067 } while ((next
= strtok (NULL
, ",")) != NULL
);
5072 return gpu_devicemask
;
5075 uint
get_random_num (uint min
, uint max
)
5077 if (min
== max
) return (min
);
5079 return (uint
) ((rand () % (max
- min
)) + min
);
5082 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5084 uint32_t quotient
= dividend
/ divisor
;
5086 if (dividend
% divisor
) quotient
++;
5091 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5093 uint64_t quotient
= dividend
/ divisor
;
5095 if (dividend
% divisor
) quotient
++;
5100 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5102 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5103 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5105 if (tm
->tm_year
- 70)
5107 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5108 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5110 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5112 else if (tm
->tm_yday
)
5114 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5115 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5117 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5119 else if (tm
->tm_hour
)
5121 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5122 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5124 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5126 else if (tm
->tm_min
)
5128 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5129 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5131 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5135 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5137 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5141 void format_speed_display (float val
, char *buf
, size_t len
)
5152 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5163 /* generate output */
5167 snprintf (buf
, len
- 1, "%.0f ", val
);
5171 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5175 void lowercase (char *buf
, int len
)
5177 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5180 void uppercase (char *buf
, int len
)
5182 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5185 int fgetl (FILE *fp
, char *line_buf
)
5191 const int c
= fgetc (fp
);
5193 if (c
== EOF
) break;
5195 line_buf
[line_len
] = (char) c
;
5199 if (line_len
== BUFSIZ
) line_len
--;
5201 if (c
== '\n') break;
5204 if (line_len
== 0) return 0;
5206 if (line_buf
[line_len
- 1] == '\n')
5210 line_buf
[line_len
] = 0;
5213 if (line_len
== 0) return 0;
5215 if (line_buf
[line_len
- 1] == '\r')
5219 line_buf
[line_len
] = 0;
5225 int in_superchop (char *buf
)
5227 int len
= strlen (buf
);
5231 if (buf
[len
- 1] == '\n')
5238 if (buf
[len
- 1] == '\r')
5253 char **scan_directory (const char *path
)
5255 char *tmp_path
= mystrdup (path
);
5257 size_t tmp_path_len
= strlen (tmp_path
);
5259 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5261 tmp_path
[tmp_path_len
- 1] = 0;
5263 tmp_path_len
= strlen (tmp_path
);
5266 char **files
= NULL
;
5272 if ((d
= opendir (tmp_path
)) != NULL
)
5276 while ((de
= readdir (d
)) != NULL
)
5278 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5280 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5282 char *path_file
= (char *) mymalloc (path_size
+ 1);
5284 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5286 path_file
[path_size
] = 0;
5290 if ((d_test
= opendir (path_file
)) != NULL
)
5298 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5302 files
[num_files
- 1] = path_file
;
5308 else if (errno
== ENOTDIR
)
5310 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5314 files
[num_files
- 1] = mystrdup (path
);
5317 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5321 files
[num_files
- 1] = NULL
;
5328 int count_dictionaries (char **dictionary_files
)
5330 if (dictionary_files
== NULL
) return 0;
5334 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5342 char *stroptitype (const uint opti_type
)
5346 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5347 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5348 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5349 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5350 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5351 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5352 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5353 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5354 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5355 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5356 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5357 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5358 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5359 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5365 char *strparser (const uint parser_status
)
5367 switch (parser_status
)
5369 case PARSER_OK
: return ((char *) PA_000
); break;
5370 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5371 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5372 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5373 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5374 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5375 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5376 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5377 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5378 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5379 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5380 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5381 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5382 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5383 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5384 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5385 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5388 return ((char *) PA_255
);
5391 char *strhashtype (const uint hash_mode
)
5395 case 0: return ((char *) HT_00000
); break;
5396 case 10: return ((char *) HT_00010
); break;
5397 case 11: return ((char *) HT_00011
); break;
5398 case 12: return ((char *) HT_00012
); break;
5399 case 20: return ((char *) HT_00020
); break;
5400 case 21: return ((char *) HT_00021
); break;
5401 case 22: return ((char *) HT_00022
); break;
5402 case 23: return ((char *) HT_00023
); break;
5403 case 30: return ((char *) HT_00030
); break;
5404 case 40: return ((char *) HT_00040
); break;
5405 case 50: return ((char *) HT_00050
); break;
5406 case 60: return ((char *) HT_00060
); break;
5407 case 100: return ((char *) HT_00100
); break;
5408 case 101: return ((char *) HT_00101
); break;
5409 case 110: return ((char *) HT_00110
); break;
5410 case 111: return ((char *) HT_00111
); break;
5411 case 112: return ((char *) HT_00112
); break;
5412 case 120: return ((char *) HT_00120
); break;
5413 case 121: return ((char *) HT_00121
); break;
5414 case 122: return ((char *) HT_00122
); break;
5415 case 124: return ((char *) HT_00124
); break;
5416 case 130: return ((char *) HT_00130
); break;
5417 case 131: return ((char *) HT_00131
); break;
5418 case 132: return ((char *) HT_00132
); break;
5419 case 133: return ((char *) HT_00133
); break;
5420 case 140: return ((char *) HT_00140
); break;
5421 case 141: return ((char *) HT_00141
); break;
5422 case 150: return ((char *) HT_00150
); break;
5423 case 160: return ((char *) HT_00160
); break;
5424 case 190: return ((char *) HT_00190
); break;
5425 case 200: return ((char *) HT_00200
); break;
5426 case 300: return ((char *) HT_00300
); break;
5427 case 400: return ((char *) HT_00400
); break;
5428 case 500: return ((char *) HT_00500
); break;
5429 case 501: return ((char *) HT_00501
); break;
5430 case 900: return ((char *) HT_00900
); break;
5431 case 910: return ((char *) HT_00910
); break;
5432 case 1000: return ((char *) HT_01000
); break;
5433 case 1100: return ((char *) HT_01100
); break;
5434 case 1400: return ((char *) HT_01400
); break;
5435 case 1410: return ((char *) HT_01410
); break;
5436 case 1420: return ((char *) HT_01420
); break;
5437 case 1421: return ((char *) HT_01421
); break;
5438 case 1430: return ((char *) HT_01430
); break;
5439 case 1440: return ((char *) HT_01440
); break;
5440 case 1441: return ((char *) HT_01441
); break;
5441 case 1450: return ((char *) HT_01450
); break;
5442 case 1460: return ((char *) HT_01460
); break;
5443 case 1500: return ((char *) HT_01500
); break;
5444 case 1600: return ((char *) HT_01600
); break;
5445 case 1700: return ((char *) HT_01700
); break;
5446 case 1710: return ((char *) HT_01710
); break;
5447 case 1711: return ((char *) HT_01711
); break;
5448 case 1720: return ((char *) HT_01720
); break;
5449 case 1722: return ((char *) HT_01722
); break;
5450 case 1730: return ((char *) HT_01730
); break;
5451 case 1731: return ((char *) HT_01731
); break;
5452 case 1740: return ((char *) HT_01740
); break;
5453 case 1750: return ((char *) HT_01750
); break;
5454 case 1760: return ((char *) HT_01760
); break;
5455 case 1800: return ((char *) HT_01800
); break;
5456 case 2100: return ((char *) HT_02100
); break;
5457 case 2400: return ((char *) HT_02400
); break;
5458 case 2410: return ((char *) HT_02410
); break;
5459 case 2500: return ((char *) HT_02500
); break;
5460 case 2600: return ((char *) HT_02600
); break;
5461 case 2611: return ((char *) HT_02611
); break;
5462 case 2612: return ((char *) HT_02612
); break;
5463 case 2711: return ((char *) HT_02711
); break;
5464 case 2811: return ((char *) HT_02811
); break;
5465 case 3000: return ((char *) HT_03000
); break;
5466 case 3100: return ((char *) HT_03100
); break;
5467 case 3200: return ((char *) HT_03200
); break;
5468 case 3710: return ((char *) HT_03710
); break;
5469 case 3711: return ((char *) HT_03711
); break;
5470 case 3800: return ((char *) HT_03800
); break;
5471 case 4300: return ((char *) HT_04300
); break;
5472 case 4400: return ((char *) HT_04400
); break;
5473 case 4500: return ((char *) HT_04500
); break;
5474 case 4700: return ((char *) HT_04700
); break;
5475 case 4800: return ((char *) HT_04800
); break;
5476 case 4900: return ((char *) HT_04900
); break;
5477 case 5000: return ((char *) HT_05000
); break;
5478 case 5100: return ((char *) HT_05100
); break;
5479 case 5200: return ((char *) HT_05200
); break;
5480 case 5300: return ((char *) HT_05300
); break;
5481 case 5400: return ((char *) HT_05400
); break;
5482 case 5500: return ((char *) HT_05500
); break;
5483 case 5600: return ((char *) HT_05600
); break;
5484 case 5700: return ((char *) HT_05700
); break;
5485 case 5800: return ((char *) HT_05800
); break;
5486 case 6000: return ((char *) HT_06000
); break;
5487 case 6100: return ((char *) HT_06100
); break;
5488 case 6211: return ((char *) HT_06211
); break;
5489 case 6212: return ((char *) HT_06212
); break;
5490 case 6213: return ((char *) HT_06213
); break;
5491 case 6221: return ((char *) HT_06221
); break;
5492 case 6222: return ((char *) HT_06222
); break;
5493 case 6223: return ((char *) HT_06223
); break;
5494 case 6231: return ((char *) HT_06231
); break;
5495 case 6232: return ((char *) HT_06232
); break;
5496 case 6233: return ((char *) HT_06233
); break;
5497 case 6241: return ((char *) HT_06241
); break;
5498 case 6242: return ((char *) HT_06242
); break;
5499 case 6243: return ((char *) HT_06243
); break;
5500 case 6300: return ((char *) HT_06300
); break;
5501 case 6400: return ((char *) HT_06400
); break;
5502 case 6500: return ((char *) HT_06500
); break;
5503 case 6600: return ((char *) HT_06600
); break;
5504 case 6700: return ((char *) HT_06700
); break;
5505 case 6800: return ((char *) HT_06800
); break;
5506 case 6900: return ((char *) HT_06900
); break;
5507 case 7100: return ((char *) HT_07100
); break;
5508 case 7200: return ((char *) HT_07200
); break;
5509 case 7300: return ((char *) HT_07300
); break;
5510 case 7400: return ((char *) HT_07400
); break;
5511 case 7500: return ((char *) HT_07500
); break;
5512 case 7600: return ((char *) HT_07600
); break;
5513 case 7700: return ((char *) HT_07700
); break;
5514 case 7800: return ((char *) HT_07800
); break;
5515 case 7900: return ((char *) HT_07900
); break;
5516 case 8000: return ((char *) HT_08000
); break;
5517 case 8100: return ((char *) HT_08100
); break;
5518 case 8200: return ((char *) HT_08200
); break;
5519 case 8300: return ((char *) HT_08300
); break;
5520 case 8400: return ((char *) HT_08400
); break;
5521 case 8500: return ((char *) HT_08500
); break;
5522 case 8600: return ((char *) HT_08600
); break;
5523 case 8700: return ((char *) HT_08700
); break;
5524 case 8800: return ((char *) HT_08800
); break;
5525 case 8900: return ((char *) HT_08900
); break;
5526 case 9000: return ((char *) HT_09000
); break;
5527 case 9100: return ((char *) HT_09100
); break;
5528 case 9200: return ((char *) HT_09200
); break;
5529 case 9300: return ((char *) HT_09300
); break;
5530 case 9400: return ((char *) HT_09400
); break;
5531 case 9500: return ((char *) HT_09500
); break;
5532 case 9600: return ((char *) HT_09600
); break;
5533 case 9700: return ((char *) HT_09700
); break;
5534 case 9710: return ((char *) HT_09710
); break;
5535 case 9720: return ((char *) HT_09720
); break;
5536 case 9800: return ((char *) HT_09800
); break;
5537 case 9810: return ((char *) HT_09810
); break;
5538 case 9820: return ((char *) HT_09820
); break;
5539 case 9900: return ((char *) HT_09900
); break;
5540 case 10000: return ((char *) HT_10000
); break;
5541 case 10100: return ((char *) HT_10100
); break;
5542 case 10200: return ((char *) HT_10200
); break;
5543 case 10300: return ((char *) HT_10300
); break;
5544 case 10400: return ((char *) HT_10400
); break;
5545 case 10410: return ((char *) HT_10410
); break;
5546 case 10420: return ((char *) HT_10420
); break;
5547 case 10500: return ((char *) HT_10500
); break;
5548 case 10600: return ((char *) HT_10600
); break;
5549 case 10700: return ((char *) HT_10700
); break;
5550 case 10800: return ((char *) HT_10800
); break;
5551 case 10900: return ((char *) HT_10900
); break;
5552 case 11000: return ((char *) HT_11000
); break;
5553 case 11100: return ((char *) HT_11100
); break;
5554 case 11200: return ((char *) HT_11200
); break;
5555 case 11300: return ((char *) HT_11300
); break;
5556 case 11400: return ((char *) HT_11400
); break;
5557 case 11500: return ((char *) HT_11500
); break;
5558 case 11600: return ((char *) HT_11600
); break;
5559 case 11700: return ((char *) HT_11700
); break;
5560 case 11800: return ((char *) HT_11800
); break;
5561 case 11900: return ((char *) HT_11900
); break;
5562 case 12000: return ((char *) HT_12000
); break;
5563 case 12100: return ((char *) HT_12100
); break;
5564 case 12200: return ((char *) HT_12200
); break;
5565 case 12300: return ((char *) HT_12300
); break;
5566 case 12400: return ((char *) HT_12400
); break;
5567 case 12500: return ((char *) HT_12500
); break;
5568 case 12600: return ((char *) HT_12600
); break;
5569 case 12700: return ((char *) HT_12700
); break;
5570 case 12800: return ((char *) HT_12800
); break;
5573 return ((char *) "Unknown");
5576 char *strstatus (const uint devices_status
)
5578 switch (devices_status
)
5580 case STATUS_INIT
: return ((char *) ST_0000
); break;
5581 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5582 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5583 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5584 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5585 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5586 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5587 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5588 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5589 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5592 return ((char *) "Unknown");
5595 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5597 uint hash_type
= data
.hash_type
;
5598 uint hash_mode
= data
.hash_mode
;
5599 uint salt_type
= data
.salt_type
;
5600 uint opts_type
= data
.opts_type
;
5601 uint opti_type
= data
.opti_type
;
5602 uint dgst_size
= data
.dgst_size
;
5604 char *hashfile
= data
.hashfile
;
5608 uint digest_buf
[64];
5610 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5612 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5614 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5616 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5622 case HASH_TYPE_DESCRYPT
:
5623 FP (digest_buf
[1], digest_buf
[0], tt
);
5626 case HASH_TYPE_DESRACF
:
5627 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5628 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5630 FP (digest_buf
[1], digest_buf
[0], tt
);
5634 FP (digest_buf
[1], digest_buf
[0], tt
);
5637 case HASH_TYPE_NETNTLM
:
5638 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5639 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5640 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5641 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5643 FP (digest_buf
[1], digest_buf
[0], tt
);
5644 FP (digest_buf
[3], digest_buf
[2], tt
);
5647 case HASH_TYPE_BSDICRYPT
:
5648 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5649 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5651 FP (digest_buf
[1], digest_buf
[0], tt
);
5656 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5661 digest_buf
[0] += MD4M_A
;
5662 digest_buf
[1] += MD4M_B
;
5663 digest_buf
[2] += MD4M_C
;
5664 digest_buf
[3] += MD4M_D
;
5668 digest_buf
[0] += MD5M_A
;
5669 digest_buf
[1] += MD5M_B
;
5670 digest_buf
[2] += MD5M_C
;
5671 digest_buf
[3] += MD5M_D
;
5674 case HASH_TYPE_SHA1
:
5675 digest_buf
[0] += SHA1M_A
;
5676 digest_buf
[1] += SHA1M_B
;
5677 digest_buf
[2] += SHA1M_C
;
5678 digest_buf
[3] += SHA1M_D
;
5679 digest_buf
[4] += SHA1M_E
;
5682 case HASH_TYPE_SHA256
:
5683 digest_buf
[0] += SHA256M_A
;
5684 digest_buf
[1] += SHA256M_B
;
5685 digest_buf
[2] += SHA256M_C
;
5686 digest_buf
[3] += SHA256M_D
;
5687 digest_buf
[4] += SHA256M_E
;
5688 digest_buf
[5] += SHA256M_F
;
5689 digest_buf
[6] += SHA256M_G
;
5690 digest_buf
[7] += SHA256M_H
;
5693 case HASH_TYPE_SHA384
:
5694 digest_buf64
[0] += SHA384M_A
;
5695 digest_buf64
[1] += SHA384M_B
;
5696 digest_buf64
[2] += SHA384M_C
;
5697 digest_buf64
[3] += SHA384M_D
;
5698 digest_buf64
[4] += SHA384M_E
;
5699 digest_buf64
[5] += SHA384M_F
;
5700 digest_buf64
[6] += 0;
5701 digest_buf64
[7] += 0;
5704 case HASH_TYPE_SHA512
:
5705 digest_buf64
[0] += SHA512M_A
;
5706 digest_buf64
[1] += SHA512M_B
;
5707 digest_buf64
[2] += SHA512M_C
;
5708 digest_buf64
[3] += SHA512M_D
;
5709 digest_buf64
[4] += SHA512M_E
;
5710 digest_buf64
[5] += SHA512M_F
;
5711 digest_buf64
[6] += SHA512M_G
;
5712 digest_buf64
[7] += SHA512M_H
;
5717 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5719 if (dgst_size
== DGST_SIZE_4_2
)
5721 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5723 else if (dgst_size
== DGST_SIZE_4_4
)
5725 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5727 else if (dgst_size
== DGST_SIZE_4_5
)
5729 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5731 else if (dgst_size
== DGST_SIZE_4_6
)
5733 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5735 else if (dgst_size
== DGST_SIZE_4_8
)
5737 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5739 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5741 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5743 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5745 else if (hash_type
== HASH_TYPE_SHA384
)
5747 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5749 else if (hash_type
== HASH_TYPE_SHA512
)
5751 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5753 else if (hash_type
== HASH_TYPE_GOST
)
5755 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5758 else if (dgst_size
== DGST_SIZE_4_64
)
5760 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5762 else if (dgst_size
== DGST_SIZE_8_25
)
5764 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5768 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5769 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5770 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5776 memset (&salt
, 0, sizeof (salt_t
));
5778 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5780 char *ptr
= (char *) salt
.salt_buf
;
5782 uint len
= salt
.salt_len
;
5784 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5790 case HASH_TYPE_NETNTLM
:
5792 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5793 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5795 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5801 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5803 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5811 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5813 uint max
= salt
.salt_len
/ 4;
5817 for (uint i
= 0; i
< max
; i
++)
5819 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5823 if (opts_type
& OPTS_TYPE_ST_HEX
)
5827 memset (tmp
, 0, sizeof (tmp
));
5829 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5831 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5836 memcpy (ptr
, tmp
, len
);
5839 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5841 memset (ptr
+ len
, 0, memset_size
);
5843 salt
.salt_len
= len
;
5847 // some modes require special encoding
5850 uint out_buf_plain
[256];
5851 uint out_buf_salt
[256];
5855 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5856 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5858 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5860 char *ptr_plain
= (char *) out_buf_plain
;
5861 char *ptr_salt
= (char *) out_buf_salt
;
5863 if (hash_mode
== 22)
5867 memset (username
, 0, sizeof (username
));
5869 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5871 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5873 uint16_t *ptr
= (uint16_t *) digest_buf
;
5875 tmp_buf
[ 0] = sig
[0];
5876 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5877 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5878 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5879 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5880 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5881 tmp_buf
[ 6] = sig
[1];
5882 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5883 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5884 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5885 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5886 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5887 tmp_buf
[12] = sig
[2];
5888 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5889 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5890 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5891 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5892 tmp_buf
[17] = sig
[3];
5893 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5894 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5895 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5896 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5897 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5898 tmp_buf
[23] = sig
[4];
5899 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5900 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5901 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5902 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5903 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5904 tmp_buf
[29] = sig
[5];
5906 snprintf (out_buf
, len
-1, "%s:%s",
5910 else if (hash_mode
== 23)
5912 // do not show the \nskyper\n part in output
5914 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5916 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5918 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5925 else if (hash_mode
== 101)
5927 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5929 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5930 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5931 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5932 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5933 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5935 memcpy (tmp_buf
, digest_buf
, 20);
5937 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5939 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5941 else if (hash_mode
== 111)
5943 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5945 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5946 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5947 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5948 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5949 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5951 memcpy (tmp_buf
, digest_buf
, 20);
5952 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5954 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5956 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
5958 else if (hash_mode
== 122)
5960 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
5961 (unsigned char *) salt
.salt_buf
,
5968 else if (hash_mode
== 124)
5970 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
5971 (unsigned char *) salt
.salt_buf
,
5978 else if (hash_mode
== 131)
5980 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
5981 (unsigned char *) salt
.salt_buf
,
5989 else if (hash_mode
== 132)
5991 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
5992 (unsigned char *) salt
.salt_buf
,
5999 else if (hash_mode
== 133)
6001 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6003 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6004 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6005 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6006 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6007 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6009 memcpy (tmp_buf
, digest_buf
, 20);
6011 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6013 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6015 else if (hash_mode
== 141)
6017 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6019 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6021 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6023 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6025 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6026 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6027 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6028 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6029 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6031 memcpy (tmp_buf
, digest_buf
, 20);
6033 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6037 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6039 else if (hash_mode
== 400)
6041 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6043 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6044 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6045 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6046 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6048 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6050 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6052 else if (hash_mode
== 500)
6054 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6056 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6057 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6058 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6059 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6061 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6063 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6065 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6069 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6072 else if (hash_mode
== 501)
6074 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6076 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6077 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6079 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6081 else if (hash_mode
== 1421)
6083 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6085 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6101 else if (hash_mode
== 1441)
6103 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6105 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6107 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6109 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6111 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6112 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6113 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6114 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6115 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6116 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6117 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6118 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6120 memcpy (tmp_buf
, digest_buf
, 32);
6122 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6126 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6128 else if (hash_mode
== 1500)
6130 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6131 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6132 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6133 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6134 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6136 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6138 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6140 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6141 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6143 memcpy (tmp_buf
, digest_buf
, 8);
6145 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6147 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6151 else if (hash_mode
== 1600)
6153 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6155 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6156 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6157 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6158 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6160 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6162 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6164 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6168 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6171 else if (hash_mode
== 1711)
6173 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6175 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6176 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6177 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6178 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6179 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6180 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6181 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6182 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6184 memcpy (tmp_buf
, digest_buf
, 64);
6185 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6187 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6189 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6191 else if (hash_mode
== 1722)
6193 uint
*ptr
= digest_buf
;
6195 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6196 (unsigned char *) salt
.salt_buf
,
6206 else if (hash_mode
== 1731)
6208 uint
*ptr
= digest_buf
;
6210 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6211 (unsigned char *) salt
.salt_buf
,
6221 else if (hash_mode
== 1800)
6225 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6226 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6227 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6228 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6229 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6230 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6231 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6232 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6234 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6236 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6238 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6242 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6245 else if (hash_mode
== 2100)
6249 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6251 salt
.salt_iter
+ 1);
6253 uint signature_len
= strlen (out_buf
);
6255 pos
+= signature_len
;
6256 len
-= signature_len
;
6258 char *salt_ptr
= (char *) salt
.salt_buf
;
6260 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6262 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6263 byte_swap_32 (digest_buf
[0]),
6264 byte_swap_32 (digest_buf
[1]),
6265 byte_swap_32 (digest_buf
[2]),
6266 byte_swap_32 (digest_buf
[3]));
6268 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6270 memcpy (tmp_buf
, digest_buf
, 16);
6272 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6274 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6275 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6276 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6277 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6279 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6280 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6281 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6282 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6284 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6285 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6286 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6287 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6289 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6290 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6291 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6292 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6294 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6295 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6296 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6297 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6301 else if (hash_mode
== 2500)
6303 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6305 wpa_t
*wpa
= &wpas
[salt_pos
];
6309 char *pke_ptr
= (char *) pke
;
6311 for (uint i
= 0; i
< 25; i
++)
6313 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6316 unsigned char mac1
[6];
6317 unsigned char mac2
[6];
6319 memcpy (mac1
, pke_ptr
+ 23, 6);
6320 memcpy (mac2
, pke_ptr
+ 29, 6);
6322 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6323 (char *) salt
.salt_buf
,
6337 else if (hash_mode
== 4400)
6339 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6340 byte_swap_32 (digest_buf
[0]),
6341 byte_swap_32 (digest_buf
[1]),
6342 byte_swap_32 (digest_buf
[2]),
6343 byte_swap_32 (digest_buf
[3]));
6345 else if (hash_mode
== 4700)
6347 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6348 byte_swap_32 (digest_buf
[0]),
6349 byte_swap_32 (digest_buf
[1]),
6350 byte_swap_32 (digest_buf
[2]),
6351 byte_swap_32 (digest_buf
[3]),
6352 byte_swap_32 (digest_buf
[4]));
6354 else if (hash_mode
== 4800)
6356 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6358 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6363 byte_swap_32 (salt
.salt_buf
[0]),
6364 byte_swap_32 (salt
.salt_buf
[1]),
6365 byte_swap_32 (salt
.salt_buf
[2]),
6366 byte_swap_32 (salt
.salt_buf
[3]),
6369 else if (hash_mode
== 4900)
6371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6372 byte_swap_32 (digest_buf
[0]),
6373 byte_swap_32 (digest_buf
[1]),
6374 byte_swap_32 (digest_buf
[2]),
6375 byte_swap_32 (digest_buf
[3]),
6376 byte_swap_32 (digest_buf
[4]));
6378 else if (hash_mode
== 5100)
6380 snprintf (out_buf
, len
-1, "%08x%08x",
6384 else if (hash_mode
== 5200)
6386 snprintf (out_buf
, len
-1, "%s", hashfile
);
6388 else if (hash_mode
== 5300)
6390 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6392 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6394 int buf_len
= len
-1;
6398 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6400 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6402 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6404 snprintf (out_buf
, buf_len
, ":");
6410 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6418 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6420 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6422 if ((i
== 0) || (i
== 5))
6424 snprintf (out_buf
, buf_len
, ":");
6430 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6438 for (uint i
= 0; i
< 4; i
++)
6442 snprintf (out_buf
, buf_len
, ":");
6448 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6454 else if (hash_mode
== 5400)
6456 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6458 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6460 int buf_len
= len
-1;
6464 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6466 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6468 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6470 snprintf (out_buf
, buf_len
, ":");
6476 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6484 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6486 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6488 if ((i
== 0) || (i
== 5))
6490 snprintf (out_buf
, buf_len
, ":");
6496 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6504 for (uint i
= 0; i
< 5; i
++)
6508 snprintf (out_buf
, buf_len
, ":");
6514 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6520 else if (hash_mode
== 5500)
6522 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6524 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6527 char domain_buf
[64];
6528 char srvchall_buf
[1024];
6529 char clichall_buf
[1024];
6531 memset (user_buf
, 0, sizeof (user_buf
));
6532 memset (domain_buf
, 0, sizeof (domain_buf
));
6533 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6534 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6536 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6538 char *ptr
= (char *) netntlm
->userdomain_buf
;
6540 user_buf
[i
] = ptr
[j
];
6543 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6545 char *ptr
= (char *) netntlm
->userdomain_buf
;
6547 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6550 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6552 char *ptr
= (char *) netntlm
->chall_buf
;
6554 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6557 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6559 char *ptr
= (char *) netntlm
->chall_buf
;
6561 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6564 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6572 byte_swap_32 (salt
.salt_buf_pc
[0]),
6573 byte_swap_32 (salt
.salt_buf_pc
[1]),
6576 else if (hash_mode
== 5600)
6578 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6580 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6583 char domain_buf
[64];
6584 char srvchall_buf
[1024];
6585 char clichall_buf
[1024];
6587 memset (user_buf
, 0, sizeof (user_buf
));
6588 memset (domain_buf
, 0, sizeof (domain_buf
));
6589 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6590 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6592 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6594 char *ptr
= (char *) netntlm
->userdomain_buf
;
6596 user_buf
[i
] = ptr
[j
];
6599 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6601 char *ptr
= (char *) netntlm
->userdomain_buf
;
6603 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6606 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6608 char *ptr
= (char *) netntlm
->chall_buf
;
6610 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6613 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6615 char *ptr
= (char *) netntlm
->chall_buf
;
6617 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6620 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6630 else if (hash_mode
== 5700)
6632 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6634 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6635 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6636 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6637 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6638 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6639 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6640 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6641 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6643 memcpy (tmp_buf
, digest_buf
, 32);
6645 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6649 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6651 else if (hash_mode
== 5800)
6653 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6654 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6655 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6656 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6657 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6659 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6666 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6668 snprintf (out_buf
, len
-1, "%s", hashfile
);
6670 else if (hash_mode
== 6300)
6672 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6674 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6675 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6676 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6677 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6679 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6681 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6683 else if (hash_mode
== 6400)
6685 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6687 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6689 else if (hash_mode
== 6500)
6691 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6693 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6695 else if (hash_mode
== 6600)
6697 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6699 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6701 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6702 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6704 uint buf_len
= len
- 1;
6706 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6709 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6711 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6716 else if (hash_mode
== 6700)
6718 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6720 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6722 else if (hash_mode
== 6800)
6724 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6726 else if (hash_mode
== 7100)
6728 uint
*ptr
= digest_buf
;
6730 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6732 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6736 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6737 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6738 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6739 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6740 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6741 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6742 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6743 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6745 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",
6746 SIGNATURE_SHA512OSX
,
6748 esalt
[ 0], esalt
[ 1],
6749 esalt
[ 2], esalt
[ 3],
6750 esalt
[ 4], esalt
[ 5],
6751 esalt
[ 6], esalt
[ 7],
6759 ptr
[15], ptr
[14]);
6761 else if (hash_mode
== 7200)
6763 uint
*ptr
= digest_buf
;
6765 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6767 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6771 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6773 len_used
= strlen (out_buf
);
6775 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6777 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6779 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6782 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",
6790 ptr
[15], ptr
[14]);
6792 else if (hash_mode
== 7300)
6794 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6796 rakp_t
*rakp
= &rakps
[salt_pos
];
6798 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6800 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6803 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6810 else if (hash_mode
== 7400)
6812 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6814 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6815 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6816 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6817 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6818 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6819 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6820 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6821 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6823 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6825 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6827 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6831 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6834 else if (hash_mode
== 7500)
6836 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6838 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6840 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6841 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6845 char *ptr_data
= data
;
6847 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6849 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6852 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6854 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6859 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6861 (char *) krb5pa
->user
,
6862 (char *) krb5pa
->realm
,
6863 (char *) krb5pa
->salt
,
6866 else if (hash_mode
== 7700)
6868 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6869 (char *) salt
.salt_buf
,
6873 else if (hash_mode
== 7800)
6875 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6876 (char *) salt
.salt_buf
,
6883 else if (hash_mode
== 7900)
6885 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6889 char *tmp
= (char *) salt
.salt_buf_pc
;
6891 ptr_plain
[42] = tmp
[0];
6897 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6899 else if (hash_mode
== 8000)
6901 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6902 (unsigned char *) salt
.salt_buf
,
6912 else if (hash_mode
== 8100)
6914 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6915 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6917 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6918 (unsigned char *) salt
.salt_buf
,
6925 else if (hash_mode
== 8200)
6927 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6929 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6931 char data_buf
[4096];
6933 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6935 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6938 data_buf
[cloudkey
->data_len
* 2] = 0;
6940 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6941 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6942 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6943 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6944 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6945 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6946 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6947 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6949 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6950 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6951 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6952 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6954 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
6970 else if (hash_mode
== 8300)
6974 char digest_buf_c
[33];
6976 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
6978 digest_buf_c
[32] = 0;
6982 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
6984 char domain_buf_c
[33];
6986 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
6988 for (uint i
= 0; i
< salt_pc_len
; i
++)
6990 const char next
= domain_buf_c
[i
];
6992 domain_buf_c
[i
] = '.';
6997 domain_buf_c
[salt_pc_len
] = 0;
7001 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7003 else if (hash_mode
== 8500)
7005 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7007 else if (hash_mode
== 2612)
7009 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7011 (char *) salt
.salt_buf
,
7017 else if (hash_mode
== 3711)
7019 char *salt_ptr
= (char *) salt
.salt_buf
;
7021 salt_ptr
[salt
.salt_len
- 1] = 0;
7023 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7024 SIGNATURE_MEDIAWIKI_B
,
7031 else if (hash_mode
== 8800)
7033 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7035 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7039 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7041 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7046 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7047 SIGNATURE_ANDROIDFDE
,
7048 byte_swap_32 (salt
.salt_buf
[0]),
7049 byte_swap_32 (salt
.salt_buf
[1]),
7050 byte_swap_32 (salt
.salt_buf
[2]),
7051 byte_swap_32 (salt
.salt_buf
[3]),
7052 byte_swap_32 (digest_buf
[0]),
7053 byte_swap_32 (digest_buf
[1]),
7054 byte_swap_32 (digest_buf
[2]),
7055 byte_swap_32 (digest_buf
[3]),
7058 else if (hash_mode
== 8900)
7060 uint N
= salt
.scrypt_N
;
7061 uint r
= salt
.scrypt_r
;
7062 uint p
= salt
.scrypt_p
;
7064 char base64_salt
[32];
7066 memset (base64_salt
, 0, 32);
7068 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7070 memset (tmp_buf
, 0, 46);
7072 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7073 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7074 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7075 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7076 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7077 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7078 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7079 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7080 digest_buf
[8] = 0; // needed for base64_encode ()
7082 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7084 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7092 else if (hash_mode
== 9000)
7094 snprintf (out_buf
, len
-1, "%s", hashfile
);
7096 else if (hash_mode
== 9200)
7100 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7102 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7104 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7108 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7109 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7110 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7111 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7112 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7113 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7114 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7115 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7116 digest_buf
[8] = 0; // needed for base64_encode ()
7119 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7121 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7122 tmp_buf
[43] = 0; // cut it here
7126 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7128 else if (hash_mode
== 9300)
7130 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7131 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7132 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7133 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7134 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7135 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7136 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7137 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7138 digest_buf
[8] = 0; // needed for base64_encode ()
7141 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7143 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7144 tmp_buf
[43] = 0; // cut it here
7146 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7148 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7150 else if (hash_mode
== 9400)
7152 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7154 office2007_t
*office2007
= &office2007s
[salt_pos
];
7156 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7157 SIGNATURE_OFFICE2007
,
7160 office2007
->keySize
,
7166 office2007
->encryptedVerifier
[0],
7167 office2007
->encryptedVerifier
[1],
7168 office2007
->encryptedVerifier
[2],
7169 office2007
->encryptedVerifier
[3],
7170 office2007
->encryptedVerifierHash
[0],
7171 office2007
->encryptedVerifierHash
[1],
7172 office2007
->encryptedVerifierHash
[2],
7173 office2007
->encryptedVerifierHash
[3],
7174 office2007
->encryptedVerifierHash
[4]);
7176 else if (hash_mode
== 9500)
7178 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7180 office2010_t
*office2010
= &office2010s
[salt_pos
];
7182 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,
7188 office2010
->encryptedVerifier
[0],
7189 office2010
->encryptedVerifier
[1],
7190 office2010
->encryptedVerifier
[2],
7191 office2010
->encryptedVerifier
[3],
7192 office2010
->encryptedVerifierHash
[0],
7193 office2010
->encryptedVerifierHash
[1],
7194 office2010
->encryptedVerifierHash
[2],
7195 office2010
->encryptedVerifierHash
[3],
7196 office2010
->encryptedVerifierHash
[4],
7197 office2010
->encryptedVerifierHash
[5],
7198 office2010
->encryptedVerifierHash
[6],
7199 office2010
->encryptedVerifierHash
[7]);
7201 else if (hash_mode
== 9600)
7203 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7205 office2013_t
*office2013
= &office2013s
[salt_pos
];
7207 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,
7213 office2013
->encryptedVerifier
[0],
7214 office2013
->encryptedVerifier
[1],
7215 office2013
->encryptedVerifier
[2],
7216 office2013
->encryptedVerifier
[3],
7217 office2013
->encryptedVerifierHash
[0],
7218 office2013
->encryptedVerifierHash
[1],
7219 office2013
->encryptedVerifierHash
[2],
7220 office2013
->encryptedVerifierHash
[3],
7221 office2013
->encryptedVerifierHash
[4],
7222 office2013
->encryptedVerifierHash
[5],
7223 office2013
->encryptedVerifierHash
[6],
7224 office2013
->encryptedVerifierHash
[7]);
7226 else if (hash_mode
== 9700)
7228 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7230 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7232 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7233 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7234 byte_swap_32 (salt
.salt_buf
[0]),
7235 byte_swap_32 (salt
.salt_buf
[1]),
7236 byte_swap_32 (salt
.salt_buf
[2]),
7237 byte_swap_32 (salt
.salt_buf
[3]),
7238 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7239 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7240 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7241 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7242 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7243 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7244 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7245 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7247 else if (hash_mode
== 9710)
7249 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7251 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7253 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7254 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7255 byte_swap_32 (salt
.salt_buf
[0]),
7256 byte_swap_32 (salt
.salt_buf
[1]),
7257 byte_swap_32 (salt
.salt_buf
[2]),
7258 byte_swap_32 (salt
.salt_buf
[3]),
7259 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7260 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7261 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7262 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7263 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7264 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7265 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7266 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7268 else if (hash_mode
== 9720)
7270 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7272 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7274 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7276 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7277 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7278 byte_swap_32 (salt
.salt_buf
[0]),
7279 byte_swap_32 (salt
.salt_buf
[1]),
7280 byte_swap_32 (salt
.salt_buf
[2]),
7281 byte_swap_32 (salt
.salt_buf
[3]),
7282 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7283 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7284 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7285 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7286 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7287 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7288 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7289 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7296 else if (hash_mode
== 9800)
7298 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7300 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7302 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7303 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7308 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7309 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7310 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7311 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7312 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7313 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7314 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7315 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7316 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7318 else if (hash_mode
== 9810)
7320 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7322 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7324 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7325 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7330 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7331 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7332 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7333 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7334 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7335 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7336 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7337 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7338 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7340 else if (hash_mode
== 9820)
7342 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7344 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7346 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7348 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7349 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7354 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7355 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7356 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7357 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7358 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7359 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7360 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7361 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7362 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7369 else if (hash_mode
== 10000)
7373 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7375 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7377 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7381 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7382 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7383 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7384 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7385 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7386 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7387 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7388 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7389 digest_buf
[8] = 0; // needed for base64_encode ()
7392 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7394 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7398 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7400 else if (hash_mode
== 10100)
7402 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7407 byte_swap_32 (salt
.salt_buf
[0]),
7408 byte_swap_32 (salt
.salt_buf
[1]),
7409 byte_swap_32 (salt
.salt_buf
[2]),
7410 byte_swap_32 (salt
.salt_buf
[3]));
7412 else if (hash_mode
== 10200)
7414 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7416 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7420 char challenge
[100];
7422 memset (challenge
, 0, sizeof (challenge
));
7424 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7430 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7431 (char *) cram_md5
->user
,
7439 memset (response
, 0, sizeof (response
));
7441 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7443 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7445 else if (hash_mode
== 10300)
7449 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7451 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7452 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7454 uint tmp_len
= 20 + salt
.salt_len
;
7458 char base64_encoded
[100];
7460 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7462 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7464 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7466 else if (hash_mode
== 10400)
7468 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7470 pdf_t
*pdf
= &pdfs
[salt_pos
];
7472 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",
7480 byte_swap_32 (pdf
->id_buf
[0]),
7481 byte_swap_32 (pdf
->id_buf
[1]),
7482 byte_swap_32 (pdf
->id_buf
[2]),
7483 byte_swap_32 (pdf
->id_buf
[3]),
7485 byte_swap_32 (pdf
->u_buf
[0]),
7486 byte_swap_32 (pdf
->u_buf
[1]),
7487 byte_swap_32 (pdf
->u_buf
[2]),
7488 byte_swap_32 (pdf
->u_buf
[3]),
7489 byte_swap_32 (pdf
->u_buf
[4]),
7490 byte_swap_32 (pdf
->u_buf
[5]),
7491 byte_swap_32 (pdf
->u_buf
[6]),
7492 byte_swap_32 (pdf
->u_buf
[7]),
7494 byte_swap_32 (pdf
->o_buf
[0]),
7495 byte_swap_32 (pdf
->o_buf
[1]),
7496 byte_swap_32 (pdf
->o_buf
[2]),
7497 byte_swap_32 (pdf
->o_buf
[3]),
7498 byte_swap_32 (pdf
->o_buf
[4]),
7499 byte_swap_32 (pdf
->o_buf
[5]),
7500 byte_swap_32 (pdf
->o_buf
[6]),
7501 byte_swap_32 (pdf
->o_buf
[7])
7504 else if (hash_mode
== 10410)
7506 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7508 pdf_t
*pdf
= &pdfs
[salt_pos
];
7510 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",
7518 byte_swap_32 (pdf
->id_buf
[0]),
7519 byte_swap_32 (pdf
->id_buf
[1]),
7520 byte_swap_32 (pdf
->id_buf
[2]),
7521 byte_swap_32 (pdf
->id_buf
[3]),
7523 byte_swap_32 (pdf
->u_buf
[0]),
7524 byte_swap_32 (pdf
->u_buf
[1]),
7525 byte_swap_32 (pdf
->u_buf
[2]),
7526 byte_swap_32 (pdf
->u_buf
[3]),
7527 byte_swap_32 (pdf
->u_buf
[4]),
7528 byte_swap_32 (pdf
->u_buf
[5]),
7529 byte_swap_32 (pdf
->u_buf
[6]),
7530 byte_swap_32 (pdf
->u_buf
[7]),
7532 byte_swap_32 (pdf
->o_buf
[0]),
7533 byte_swap_32 (pdf
->o_buf
[1]),
7534 byte_swap_32 (pdf
->o_buf
[2]),
7535 byte_swap_32 (pdf
->o_buf
[3]),
7536 byte_swap_32 (pdf
->o_buf
[4]),
7537 byte_swap_32 (pdf
->o_buf
[5]),
7538 byte_swap_32 (pdf
->o_buf
[6]),
7539 byte_swap_32 (pdf
->o_buf
[7])
7542 else if (hash_mode
== 10420)
7544 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7546 pdf_t
*pdf
= &pdfs
[salt_pos
];
7548 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7550 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",
7558 byte_swap_32 (pdf
->id_buf
[0]),
7559 byte_swap_32 (pdf
->id_buf
[1]),
7560 byte_swap_32 (pdf
->id_buf
[2]),
7561 byte_swap_32 (pdf
->id_buf
[3]),
7563 byte_swap_32 (pdf
->u_buf
[0]),
7564 byte_swap_32 (pdf
->u_buf
[1]),
7565 byte_swap_32 (pdf
->u_buf
[2]),
7566 byte_swap_32 (pdf
->u_buf
[3]),
7567 byte_swap_32 (pdf
->u_buf
[4]),
7568 byte_swap_32 (pdf
->u_buf
[5]),
7569 byte_swap_32 (pdf
->u_buf
[6]),
7570 byte_swap_32 (pdf
->u_buf
[7]),
7572 byte_swap_32 (pdf
->o_buf
[0]),
7573 byte_swap_32 (pdf
->o_buf
[1]),
7574 byte_swap_32 (pdf
->o_buf
[2]),
7575 byte_swap_32 (pdf
->o_buf
[3]),
7576 byte_swap_32 (pdf
->o_buf
[4]),
7577 byte_swap_32 (pdf
->o_buf
[5]),
7578 byte_swap_32 (pdf
->o_buf
[6]),
7579 byte_swap_32 (pdf
->o_buf
[7]),
7587 else if (hash_mode
== 10500)
7589 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7591 pdf_t
*pdf
= &pdfs
[salt_pos
];
7593 if (pdf
->id_len
== 32)
7595 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",
7603 byte_swap_32 (pdf
->id_buf
[0]),
7604 byte_swap_32 (pdf
->id_buf
[1]),
7605 byte_swap_32 (pdf
->id_buf
[2]),
7606 byte_swap_32 (pdf
->id_buf
[3]),
7607 byte_swap_32 (pdf
->id_buf
[4]),
7608 byte_swap_32 (pdf
->id_buf
[5]),
7609 byte_swap_32 (pdf
->id_buf
[6]),
7610 byte_swap_32 (pdf
->id_buf
[7]),
7612 byte_swap_32 (pdf
->u_buf
[0]),
7613 byte_swap_32 (pdf
->u_buf
[1]),
7614 byte_swap_32 (pdf
->u_buf
[2]),
7615 byte_swap_32 (pdf
->u_buf
[3]),
7616 byte_swap_32 (pdf
->u_buf
[4]),
7617 byte_swap_32 (pdf
->u_buf
[5]),
7618 byte_swap_32 (pdf
->u_buf
[6]),
7619 byte_swap_32 (pdf
->u_buf
[7]),
7621 byte_swap_32 (pdf
->o_buf
[0]),
7622 byte_swap_32 (pdf
->o_buf
[1]),
7623 byte_swap_32 (pdf
->o_buf
[2]),
7624 byte_swap_32 (pdf
->o_buf
[3]),
7625 byte_swap_32 (pdf
->o_buf
[4]),
7626 byte_swap_32 (pdf
->o_buf
[5]),
7627 byte_swap_32 (pdf
->o_buf
[6]),
7628 byte_swap_32 (pdf
->o_buf
[7])
7633 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",
7641 byte_swap_32 (pdf
->id_buf
[0]),
7642 byte_swap_32 (pdf
->id_buf
[1]),
7643 byte_swap_32 (pdf
->id_buf
[2]),
7644 byte_swap_32 (pdf
->id_buf
[3]),
7646 byte_swap_32 (pdf
->u_buf
[0]),
7647 byte_swap_32 (pdf
->u_buf
[1]),
7648 byte_swap_32 (pdf
->u_buf
[2]),
7649 byte_swap_32 (pdf
->u_buf
[3]),
7650 byte_swap_32 (pdf
->u_buf
[4]),
7651 byte_swap_32 (pdf
->u_buf
[5]),
7652 byte_swap_32 (pdf
->u_buf
[6]),
7653 byte_swap_32 (pdf
->u_buf
[7]),
7655 byte_swap_32 (pdf
->o_buf
[0]),
7656 byte_swap_32 (pdf
->o_buf
[1]),
7657 byte_swap_32 (pdf
->o_buf
[2]),
7658 byte_swap_32 (pdf
->o_buf
[3]),
7659 byte_swap_32 (pdf
->o_buf
[4]),
7660 byte_swap_32 (pdf
->o_buf
[5]),
7661 byte_swap_32 (pdf
->o_buf
[6]),
7662 byte_swap_32 (pdf
->o_buf
[7])
7666 else if (hash_mode
== 10600)
7668 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7670 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7671 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7673 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7675 else if (hash_mode
== 10700)
7677 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7679 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7680 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7682 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7684 else if (hash_mode
== 10900)
7686 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7688 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7689 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7691 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7693 else if (hash_mode
== 11100)
7695 uint32_t salt_challenge
= salt
.salt_buf
[0];
7697 salt_challenge
= byte_swap_32 (salt_challenge
);
7699 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7701 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7702 SIGNATURE_POSTGRESQL_AUTH
,
7710 else if (hash_mode
== 11200)
7712 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7713 SIGNATURE_MYSQL_AUTH
,
7714 (unsigned char *) salt
.salt_buf
,
7721 else if (hash_mode
== 11300)
7723 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7725 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7727 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7728 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7729 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7731 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7732 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7733 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7735 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7737 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7739 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7742 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7744 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7746 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7749 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7751 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7753 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7756 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7757 SIGNATURE_BITCOIN_WALLET
,
7761 (unsigned char *) salt
.salt_buf
,
7769 free (cry_master_buf
);
7771 free (public_key_buf
);
7773 else if (hash_mode
== 11400)
7775 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7777 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7778 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7780 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7782 else if (hash_mode
== 11600)
7784 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7786 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7788 const uint data_len
= seven_zip
->data_len
;
7790 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7792 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7794 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7796 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7799 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7800 SIGNATURE_SEVEN_ZIP
,
7804 (char *) seven_zip
->salt_buf
,
7806 seven_zip
->iv_buf
[0],
7807 seven_zip
->iv_buf
[1],
7808 seven_zip
->iv_buf
[2],
7809 seven_zip
->iv_buf
[3],
7811 seven_zip
->data_len
,
7812 seven_zip
->unpack_size
,
7817 else if (hash_mode
== 11700)
7819 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7829 else if (hash_mode
== 11800)
7831 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7849 else if (hash_mode
== 11900)
7851 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7853 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7854 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7856 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7858 else if (hash_mode
== 12000)
7860 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7862 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7863 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7865 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7867 else if (hash_mode
== 12100)
7869 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7871 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7872 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7874 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7876 else if (hash_mode
== 12200)
7878 uint
*ptr_digest
= digest_buf
;
7879 uint
*ptr_salt
= salt
.salt_buf
;
7881 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7888 else if (hash_mode
== 12300)
7890 uint
*ptr_digest
= digest_buf
;
7891 uint
*ptr_salt
= salt
.salt_buf
;
7893 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",
7894 ptr_digest
[ 0], ptr_digest
[ 1],
7895 ptr_digest
[ 2], ptr_digest
[ 3],
7896 ptr_digest
[ 4], ptr_digest
[ 5],
7897 ptr_digest
[ 6], ptr_digest
[ 7],
7898 ptr_digest
[ 8], ptr_digest
[ 9],
7899 ptr_digest
[10], ptr_digest
[11],
7900 ptr_digest
[12], ptr_digest
[13],
7901 ptr_digest
[14], ptr_digest
[15],
7907 else if (hash_mode
== 12400)
7909 // encode iteration count
7913 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7914 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7915 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7916 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7921 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7922 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7923 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7924 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7929 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7931 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7932 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7934 memcpy (tmp_buf
, digest_buf
, 8);
7936 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7940 // fill the resulting buffer
7942 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7944 else if (hash_mode
== 12500)
7946 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7948 byte_swap_32 (salt
.salt_buf
[0]),
7949 byte_swap_32 (salt
.salt_buf
[1]),
7955 else if (hash_mode
== 12600)
7957 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7958 digest_buf
[0] + salt
.salt_buf_pc
[0],
7959 digest_buf
[1] + salt
.salt_buf_pc
[1],
7960 digest_buf
[2] + salt
.salt_buf_pc
[2],
7961 digest_buf
[3] + salt
.salt_buf_pc
[3],
7962 digest_buf
[4] + salt
.salt_buf_pc
[4],
7963 digest_buf
[5] + salt
.salt_buf_pc
[5],
7964 digest_buf
[6] + salt
.salt_buf_pc
[6],
7965 digest_buf
[7] + salt
.salt_buf_pc
[7]);
7967 else if (hash_mode
== 12700)
7969 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7971 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7972 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7974 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7976 else if (hash_mode
== 12800)
7978 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
7980 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",
7993 byte_swap_32 (digest_buf
[0]),
7994 byte_swap_32 (digest_buf
[1]),
7995 byte_swap_32 (digest_buf
[2]),
7996 byte_swap_32 (digest_buf
[3]),
7997 byte_swap_32 (digest_buf
[4]),
7998 byte_swap_32 (digest_buf
[5]),
7999 byte_swap_32 (digest_buf
[6]),
8000 byte_swap_32 (digest_buf
[7])
8005 if (hash_type
== HASH_TYPE_MD4
)
8007 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8013 else if (hash_type
== HASH_TYPE_MD5
)
8015 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8021 else if (hash_type
== HASH_TYPE_SHA1
)
8023 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8030 else if (hash_type
== HASH_TYPE_SHA256
)
8032 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8042 else if (hash_type
== HASH_TYPE_SHA384
)
8044 uint
*ptr
= digest_buf
;
8046 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8054 else if (hash_type
== HASH_TYPE_SHA512
)
8056 uint
*ptr
= digest_buf
;
8058 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8068 else if (hash_type
== HASH_TYPE_LM
)
8070 snprintf (out_buf
, len
-1, "%08x%08x",
8074 else if (hash_type
== HASH_TYPE_ORACLEH
)
8076 snprintf (out_buf
, len
-1, "%08X%08X",
8080 else if (hash_type
== HASH_TYPE_BCRYPT
)
8082 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8083 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8085 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8087 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8089 else if (hash_type
== HASH_TYPE_KECCAK
)
8091 uint
*ptr
= digest_buf
;
8093 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",
8121 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8123 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8125 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8132 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8134 digest_buf
[ 0] = digest_buf
[ 0];
8135 digest_buf
[ 1] = digest_buf
[ 1];
8136 digest_buf
[ 2] = digest_buf
[ 2];
8137 digest_buf
[ 3] = digest_buf
[ 3];
8138 digest_buf
[ 4] = digest_buf
[ 4];
8139 digest_buf
[ 5] = digest_buf
[ 5];
8140 digest_buf
[ 6] = digest_buf
[ 6];
8141 digest_buf
[ 7] = digest_buf
[ 7];
8142 digest_buf
[ 8] = digest_buf
[ 8];
8143 digest_buf
[ 9] = digest_buf
[ 9];
8144 digest_buf
[10] = digest_buf
[10];
8145 digest_buf
[11] = digest_buf
[11];
8146 digest_buf
[12] = digest_buf
[12];
8147 digest_buf
[13] = digest_buf
[13];
8148 digest_buf
[14] = digest_buf
[14];
8149 digest_buf
[15] = digest_buf
[15];
8151 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8169 else if (hash_type
== HASH_TYPE_GOST
)
8171 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8181 else if (hash_type
== HASH_TYPE_MYSQL
)
8183 snprintf (out_buf
, len
-1, "%08x%08x",
8187 else if (hash_type
== HASH_TYPE_LOTUS5
)
8189 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8195 else if (hash_type
== HASH_TYPE_LOTUS6
)
8197 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8198 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8199 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8200 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8204 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8205 memcpy (buf
+ 5, digest_buf
, 9);
8209 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8211 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8214 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8216 else if (hash_type
== HASH_TYPE_LOTUS8
)
8220 memset (buf
, 0, sizeof (buf
));
8224 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8230 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8234 buf
[26] = salt
.salt_buf_pc
[0];
8235 buf
[27] = salt
.salt_buf_pc
[1];
8239 memcpy (buf
+ 28, digest_buf
, 8);
8241 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8245 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8247 else if (hash_type
== HASH_TYPE_CRC32
)
8249 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8253 if (salt_type
== SALT_TYPE_INTERN
)
8255 size_t pos
= strlen (out_buf
);
8257 out_buf
[pos
] = data
.separator
;
8259 char *ptr
= (char *) salt
.salt_buf
;
8261 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8263 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8267 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8269 memset (hccap
, 0, sizeof (hccap_t
));
8271 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8273 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8275 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8276 wpa_t
*wpa
= &wpas
[salt_pos
];
8278 hccap
->keyver
= wpa
->keyver
;
8280 hccap
->eapol_size
= wpa
->eapol_size
;
8282 if (wpa
->keyver
!= 1)
8286 for (uint i
= 0; i
< 64; i
++)
8288 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8291 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8295 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8300 for (int i
= 5; i
< 25; i
++)
8302 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8305 char *pke_ptr
= (char *) pke_tmp
;
8307 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8308 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8309 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8310 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8312 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8314 uint dgst_size
= data
.dgst_size
;
8316 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8318 if (wpa
->keyver
!= 1)
8322 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8323 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8324 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8325 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8327 memcpy (hccap
->keymic
, digest_tmp
, 16);
8331 memcpy (hccap
->keymic
, digest_ptr
, 16);
8335 void SuspendThreads ()
8337 if (data
.devices_status
== STATUS_RUNNING
)
8339 hc_timer_set (&data
.timer_paused
);
8341 data
.devices_status
= STATUS_PAUSED
;
8343 log_info ("Paused");
8347 void ResumeThreads ()
8349 if (data
.devices_status
== STATUS_PAUSED
)
8353 hc_timer_get (data
.timer_paused
, ms_paused
);
8355 data
.ms_paused
+= ms_paused
;
8357 data
.devices_status
= STATUS_RUNNING
;
8359 log_info ("Resumed");
8365 if (data
.devices_status
!= STATUS_RUNNING
) return;
8367 data
.devices_status
= STATUS_BYPASS
;
8369 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8372 void stop_at_checkpoint ()
8374 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8376 if (data
.devices_status
!= STATUS_RUNNING
) return;
8379 // this feature only makes sense if --restore-disable was not specified
8381 if (data
.restore_disable
== 1)
8383 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8388 // check if monitoring of Restore Point updates should be enabled or disabled
8390 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8392 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8394 // save the current restore point value
8396 data
.checkpoint_cur_words
= get_lowest_words_done ();
8398 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8402 data
.devices_status
= STATUS_RUNNING
;
8404 // reset the global value for checkpoint checks
8406 data
.checkpoint_cur_words
= 0;
8408 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8414 if (data
.devices_status
== STATUS_INIT
) return;
8415 if (data
.devices_status
== STATUS_STARTING
) return;
8417 data
.devices_status
= STATUS_ABORTED
;
8422 if (data
.devices_status
== STATUS_INIT
) return;
8423 if (data
.devices_status
== STATUS_STARTING
) return;
8425 data
.devices_status
= STATUS_QUIT
;
8428 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8432 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8436 memset (&st
, 0, sizeof (st
));
8438 stat (kernel_file
, &st
);
8440 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8442 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8444 if (num_read
!= (size_t) st
.st_size
)
8446 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8453 buf
[st
.st_size
] = 0;
8455 for (int i
= 0; i
< num_devices
; i
++)
8457 kernel_lengths
[i
] = (size_t) st
.st_size
;
8459 kernel_sources
[i
] = buf
;
8464 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8472 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8474 FILE *fp
= fopen (dst
, "wb");
8476 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8486 restore_data_t
*init_restore (int argc
, char **argv
)
8488 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8490 if (data
.restore_disable
== 0)
8492 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8496 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8500 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8509 char pidbin
[BUFSIZ
];
8514 memset (pidbin
, 0, sizeof (pidbin
));
8516 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8518 FILE *fd
= fopen (pidbin
, "rb");
8522 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8524 pidbin
[pidbin_len
] = 0;
8528 char *argv0_r
= strrchr (argv
[0], '/');
8530 char *pidbin_r
= strrchr (pidbin
, '/');
8532 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8534 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8536 if (strcmp (argv0_r
, pidbin_r
) == 0)
8538 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8545 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8547 char pidbin2
[BUFSIZ
];
8551 memset (pidbin2
, 0, sizeof (pidbin2
));
8553 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8554 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8556 pidbin
[pidbin_len
] = 0;
8557 pidbin2
[pidbin2_len
] = 0;
8561 if (strcmp (pidbin
, pidbin2
) == 0)
8563 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8571 if (rd
->version_bin
< RESTORE_MIN
)
8573 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8580 memset (rd
, 0, sizeof (restore_data_t
));
8582 rd
->version_bin
= VERSION_BIN
;
8585 rd
->pid
= getpid ();
8587 rd
->pid
= GetCurrentProcessId ();
8590 if (getcwd (rd
->cwd
, 255) == NULL
)
8603 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8605 FILE *fp
= fopen (eff_restore_file
, "rb");
8609 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8614 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8616 log_error ("ERROR: cannot read %s", eff_restore_file
);
8621 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8623 for (uint i
= 0; i
< rd
->argc
; i
++)
8627 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8629 log_error ("ERROR: cannot read %s", eff_restore_file
);
8634 size_t len
= strlen (buf
);
8636 if (len
) buf
[len
- 1] = 0;
8638 rd
->argv
[i
] = mystrdup (buf
);
8645 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8649 log_error ("Restore file is corrupted");
8652 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8654 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8656 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8661 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8665 if (chdir (rd
->cwd
))
8667 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8673 uint64_t get_lowest_words_done ()
8675 uint64_t words_cur
= -1;
8677 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8679 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8681 const uint64_t words_done
= device_param
->words_done
;
8683 if (words_done
< words_cur
) words_cur
= words_done
;
8686 // It's possible that a GPU's workload isn't finished right after a restore-case.
8687 // In that case, this function would return 0 and overwrite the real restore point
8688 // There's also data.words_cur which is set to rd->words_cur but it changes while
8689 // the attack is running therefore we should stick to rd->words_cur.
8690 // Note that -s influences rd->words_cur we should keep a close look on that.
8692 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8697 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8699 uint64_t words_cur
= get_lowest_words_done ();
8701 rd
->words_cur
= words_cur
;
8703 FILE *fp
= fopen (new_restore_file
, "wb");
8707 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8712 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8714 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8719 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8721 for (uint i
= 0; i
< rd
->argc
; i
++)
8723 fprintf (fp
, "%s", rd
->argv
[i
]);
8729 fsync (fileno (fp
));
8734 void cycle_restore ()
8736 const char *eff_restore_file
= data
.eff_restore_file
;
8737 const char *new_restore_file
= data
.new_restore_file
;
8739 restore_data_t
*rd
= data
.rd
;
8741 write_restore (new_restore_file
, rd
);
8745 memset (&st
, 0, sizeof(st
));
8747 if (stat (eff_restore_file
, &st
) == 0)
8749 if (unlink (eff_restore_file
))
8751 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8755 if (rename (new_restore_file
, eff_restore_file
))
8757 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8761 void check_checkpoint ()
8763 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8765 uint64_t words_cur
= get_lowest_words_done ();
8767 if (words_cur
!= data
.checkpoint_cur_words
)
8777 uint
set_gpu_accel (uint hash_mode
)
8781 case 0: return GET_ACCEL (0);
8782 case 10: return GET_ACCEL (10);
8783 case 11: return GET_ACCEL (11);
8784 case 12: return GET_ACCEL (12);
8785 case 20: return GET_ACCEL (20);
8786 case 21: return GET_ACCEL (21);
8787 case 22: return GET_ACCEL (22);
8788 case 23: return GET_ACCEL (23);
8789 case 30: return GET_ACCEL (30);
8790 case 40: return GET_ACCEL (40);
8791 case 50: return GET_ACCEL (50);
8792 case 60: return GET_ACCEL (60);
8793 case 100: return GET_ACCEL (100);
8794 case 101: return GET_ACCEL (101);
8795 case 110: return GET_ACCEL (110);
8796 case 111: return GET_ACCEL (111);
8797 case 112: return GET_ACCEL (112);
8798 case 120: return GET_ACCEL (120);
8799 case 121: return GET_ACCEL (121);
8800 case 122: return GET_ACCEL (122);
8801 case 124: return GET_ACCEL (124);
8802 case 130: return GET_ACCEL (130);
8803 case 131: return GET_ACCEL (131);
8804 case 132: return GET_ACCEL (132);
8805 case 133: return GET_ACCEL (133);
8806 case 140: return GET_ACCEL (140);
8807 case 141: return GET_ACCEL (141);
8808 case 150: return GET_ACCEL (150);
8809 case 160: return GET_ACCEL (160);
8810 case 190: return GET_ACCEL (190);
8811 case 200: return GET_ACCEL (200);
8812 case 300: return GET_ACCEL (300);
8813 case 400: return GET_ACCEL (400);
8814 case 500: return GET_ACCEL (500);
8815 case 501: return GET_ACCEL (501);
8816 case 900: return GET_ACCEL (900);
8817 case 910: return GET_ACCEL (910);
8818 case 1000: return GET_ACCEL (1000);
8819 case 1100: return GET_ACCEL (1100);
8820 case 1400: return GET_ACCEL (1400);
8821 case 1410: return GET_ACCEL (1410);
8822 case 1420: return GET_ACCEL (1420);
8823 case 1421: return GET_ACCEL (1421);
8824 case 1430: return GET_ACCEL (1430);
8825 case 1440: return GET_ACCEL (1440);
8826 case 1441: return GET_ACCEL (1441);
8827 case 1450: return GET_ACCEL (1450);
8828 case 1460: return GET_ACCEL (1460);
8829 case 1500: return GET_ACCEL (1500);
8830 case 1600: return GET_ACCEL (1600);
8831 case 1700: return GET_ACCEL (1700);
8832 case 1710: return GET_ACCEL (1710);
8833 case 1711: return GET_ACCEL (1711);
8834 case 1720: return GET_ACCEL (1720);
8835 case 1722: return GET_ACCEL (1722);
8836 case 1730: return GET_ACCEL (1730);
8837 case 1731: return GET_ACCEL (1731);
8838 case 1740: return GET_ACCEL (1740);
8839 case 1750: return GET_ACCEL (1750);
8840 case 1760: return GET_ACCEL (1760);
8841 case 1800: return GET_ACCEL (1800);
8842 case 2100: return GET_ACCEL (2100);
8843 case 2400: return GET_ACCEL (2400);
8844 case 2410: return GET_ACCEL (2410);
8845 case 2500: return GET_ACCEL (2500);
8846 case 2600: return GET_ACCEL (2600);
8847 case 2611: return GET_ACCEL (2611);
8848 case 2612: return GET_ACCEL (2612);
8849 case 2711: return GET_ACCEL (2711);
8850 case 2811: return GET_ACCEL (2811);
8851 case 3000: return GET_ACCEL (3000);
8852 case 3100: return GET_ACCEL (3100);
8853 case 3200: return GET_ACCEL (3200);
8854 case 3710: return GET_ACCEL (3710);
8855 case 3711: return GET_ACCEL (3711);
8856 case 3800: return GET_ACCEL (3800);
8857 case 4300: return GET_ACCEL (4300);
8858 case 4400: return GET_ACCEL (4400);
8859 case 4500: return GET_ACCEL (4500);
8860 case 4700: return GET_ACCEL (4700);
8861 case 4800: return GET_ACCEL (4800);
8862 case 4900: return GET_ACCEL (4900);
8863 case 5000: return GET_ACCEL (5000);
8864 case 5100: return GET_ACCEL (5100);
8865 case 5200: return GET_ACCEL (5200);
8866 case 5300: return GET_ACCEL (5300);
8867 case 5400: return GET_ACCEL (5400);
8868 case 5500: return GET_ACCEL (5500);
8869 case 5600: return GET_ACCEL (5600);
8870 case 5700: return GET_ACCEL (5700);
8871 case 5800: return GET_ACCEL (5800);
8872 case 6000: return GET_ACCEL (6000);
8873 case 6100: return GET_ACCEL (6100);
8874 case 6211: return GET_ACCEL (6211);
8875 case 6212: return GET_ACCEL (6212);
8876 case 6213: return GET_ACCEL (6213);
8877 case 6221: return GET_ACCEL (6221);
8878 case 6222: return GET_ACCEL (6222);
8879 case 6223: return GET_ACCEL (6223);
8880 case 6231: return GET_ACCEL (6231);
8881 case 6232: return GET_ACCEL (6232);
8882 case 6233: return GET_ACCEL (6233);
8883 case 6241: return GET_ACCEL (6241);
8884 case 6242: return GET_ACCEL (6242);
8885 case 6243: return GET_ACCEL (6243);
8886 case 6300: return GET_ACCEL (6300);
8887 case 6400: return GET_ACCEL (6400);
8888 case 6500: return GET_ACCEL (6500);
8889 case 6600: return GET_ACCEL (6600);
8890 case 6700: return GET_ACCEL (6700);
8891 case 6800: return GET_ACCEL (6800);
8892 case 6900: return GET_ACCEL (6900);
8893 case 7100: return GET_ACCEL (7100);
8894 case 7200: return GET_ACCEL (7200);
8895 case 7300: return GET_ACCEL (7300);
8896 case 7400: return GET_ACCEL (7400);
8897 case 7500: return GET_ACCEL (7500);
8898 case 7600: return GET_ACCEL (7600);
8899 case 7700: return GET_ACCEL (7700);
8900 case 7800: return GET_ACCEL (7800);
8901 case 7900: return GET_ACCEL (7900);
8902 case 8000: return GET_ACCEL (8000);
8903 case 8100: return GET_ACCEL (8100);
8904 case 8200: return GET_ACCEL (8200);
8905 case 8300: return GET_ACCEL (8300);
8906 case 8400: return GET_ACCEL (8400);
8907 case 8500: return GET_ACCEL (8500);
8908 case 8600: return GET_ACCEL (8600);
8909 case 8700: return GET_ACCEL (8700);
8910 case 8800: return GET_ACCEL (8800);
8911 case 8900: return GET_ACCEL (8900);
8912 case 9000: return GET_ACCEL (9000);
8913 case 9100: return GET_ACCEL (9100);
8914 case 9200: return GET_ACCEL (9200);
8915 case 9300: return GET_ACCEL (9300);
8916 case 9400: return GET_ACCEL (9400);
8917 case 9500: return GET_ACCEL (9500);
8918 case 9600: return GET_ACCEL (9600);
8919 case 9700: return GET_ACCEL (9700);
8920 case 9710: return GET_ACCEL (9710);
8921 case 9720: return GET_ACCEL (9720);
8922 case 9800: return GET_ACCEL (9800);
8923 case 9810: return GET_ACCEL (9810);
8924 case 9820: return GET_ACCEL (9820);
8925 case 9900: return GET_ACCEL (9900);
8926 case 10000: return GET_ACCEL (10000);
8927 case 10100: return GET_ACCEL (10100);
8928 case 10200: return GET_ACCEL (10200);
8929 case 10300: return GET_ACCEL (10300);
8930 case 10400: return GET_ACCEL (10400);
8931 case 10410: return GET_ACCEL (10410);
8932 case 10420: return GET_ACCEL (10420);
8933 case 10500: return GET_ACCEL (10500);
8934 case 10600: return GET_ACCEL (10600);
8935 case 10700: return GET_ACCEL (10700);
8936 case 10800: return GET_ACCEL (10800);
8937 case 10900: return GET_ACCEL (10900);
8938 case 11000: return GET_ACCEL (11000);
8939 case 11100: return GET_ACCEL (11100);
8940 case 11200: return GET_ACCEL (11200);
8941 case 11300: return GET_ACCEL (11300);
8942 case 11400: return GET_ACCEL (11400);
8943 case 11500: return GET_ACCEL (11500);
8944 case 11600: return GET_ACCEL (11600);
8945 case 11700: return GET_ACCEL (11700);
8946 case 11800: return GET_ACCEL (11800);
8947 case 11900: return GET_ACCEL (11900);
8948 case 12000: return GET_ACCEL (12000);
8949 case 12100: return GET_ACCEL (12100);
8950 case 12200: return GET_ACCEL (12200);
8951 case 12300: return GET_ACCEL (12300);
8952 case 12400: return GET_ACCEL (12400);
8953 case 12500: return GET_ACCEL (12500);
8954 case 12600: return GET_ACCEL (12600);
8955 case 12700: return GET_ACCEL (12700);
8956 case 12800: return GET_ACCEL (12800);
8962 uint
set_gpu_loops (uint hash_mode
)
8966 case 0: return GET_LOOPS (0);
8967 case 10: return GET_LOOPS (10);
8968 case 11: return GET_LOOPS (11);
8969 case 12: return GET_LOOPS (12);
8970 case 20: return GET_LOOPS (20);
8971 case 21: return GET_LOOPS (21);
8972 case 22: return GET_LOOPS (22);
8973 case 23: return GET_LOOPS (23);
8974 case 30: return GET_LOOPS (30);
8975 case 40: return GET_LOOPS (40);
8976 case 50: return GET_LOOPS (50);
8977 case 60: return GET_LOOPS (60);
8978 case 100: return GET_LOOPS (100);
8979 case 101: return GET_LOOPS (101);
8980 case 110: return GET_LOOPS (110);
8981 case 111: return GET_LOOPS (111);
8982 case 112: return GET_LOOPS (112);
8983 case 120: return GET_LOOPS (120);
8984 case 121: return GET_LOOPS (121);
8985 case 122: return GET_LOOPS (122);
8986 case 124: return GET_LOOPS (124);
8987 case 130: return GET_LOOPS (130);
8988 case 131: return GET_LOOPS (131);
8989 case 132: return GET_LOOPS (132);
8990 case 133: return GET_LOOPS (133);
8991 case 140: return GET_LOOPS (140);
8992 case 141: return GET_LOOPS (141);
8993 case 150: return GET_LOOPS (150);
8994 case 160: return GET_LOOPS (160);
8995 case 190: return GET_LOOPS (190);
8996 case 200: return GET_LOOPS (200);
8997 case 300: return GET_LOOPS (300);
8998 case 400: return GET_LOOPS (400);
8999 case 500: return GET_LOOPS (500);
9000 case 501: return GET_LOOPS (501);
9001 case 900: return GET_LOOPS (900);
9002 case 910: return GET_LOOPS (910);
9003 case 1000: return GET_LOOPS (1000);
9004 case 1100: return GET_LOOPS (1100);
9005 case 1400: return GET_LOOPS (1400);
9006 case 1410: return GET_LOOPS (1410);
9007 case 1420: return GET_LOOPS (1420);
9008 case 1421: return GET_LOOPS (1421);
9009 case 1430: return GET_LOOPS (1430);
9010 case 1440: return GET_LOOPS (1440);
9011 case 1441: return GET_LOOPS (1441);
9012 case 1450: return GET_LOOPS (1450);
9013 case 1460: return GET_LOOPS (1460);
9014 case 1500: return GET_LOOPS (1500);
9015 case 1600: return GET_LOOPS (1600);
9016 case 1700: return GET_LOOPS (1700);
9017 case 1710: return GET_LOOPS (1710);
9018 case 1711: return GET_LOOPS (1711);
9019 case 1720: return GET_LOOPS (1720);
9020 case 1722: return GET_LOOPS (1722);
9021 case 1730: return GET_LOOPS (1730);
9022 case 1731: return GET_LOOPS (1731);
9023 case 1740: return GET_LOOPS (1740);
9024 case 1750: return GET_LOOPS (1750);
9025 case 1760: return GET_LOOPS (1760);
9026 case 1800: return GET_LOOPS (1800);
9027 case 2100: return GET_LOOPS (2100);
9028 case 2400: return GET_LOOPS (2400);
9029 case 2410: return GET_LOOPS (2410);
9030 case 2500: return GET_LOOPS (2500);
9031 case 2600: return GET_LOOPS (2600);
9032 case 2611: return GET_LOOPS (2611);
9033 case 2612: return GET_LOOPS (2612);
9034 case 2711: return GET_LOOPS (2711);
9035 case 2811: return GET_LOOPS (2811);
9036 case 3000: return GET_LOOPS (3000);
9037 case 3100: return GET_LOOPS (3100);
9038 case 3200: return GET_LOOPS (3200);
9039 case 3710: return GET_LOOPS (3710);
9040 case 3711: return GET_LOOPS (3711);
9041 case 3800: return GET_LOOPS (3800);
9042 case 4300: return GET_LOOPS (4300);
9043 case 4400: return GET_LOOPS (4400);
9044 case 4500: return GET_LOOPS (4500);
9045 case 4700: return GET_LOOPS (4700);
9046 case 4800: return GET_LOOPS (4800);
9047 case 4900: return GET_LOOPS (4900);
9048 case 5000: return GET_LOOPS (5000);
9049 case 5100: return GET_LOOPS (5100);
9050 case 5200: return GET_LOOPS (5200);
9051 case 5300: return GET_LOOPS (5300);
9052 case 5400: return GET_LOOPS (5400);
9053 case 5500: return GET_LOOPS (5500);
9054 case 5600: return GET_LOOPS (5600);
9055 case 5700: return GET_LOOPS (5700);
9056 case 5800: return GET_LOOPS (5800);
9057 case 6000: return GET_LOOPS (6000);
9058 case 6100: return GET_LOOPS (6100);
9059 case 6211: return GET_LOOPS (6211);
9060 case 6212: return GET_LOOPS (6212);
9061 case 6213: return GET_LOOPS (6213);
9062 case 6221: return GET_LOOPS (6221);
9063 case 6222: return GET_LOOPS (6222);
9064 case 6223: return GET_LOOPS (6223);
9065 case 6231: return GET_LOOPS (6231);
9066 case 6232: return GET_LOOPS (6232);
9067 case 6233: return GET_LOOPS (6233);
9068 case 6241: return GET_LOOPS (6241);
9069 case 6242: return GET_LOOPS (6242);
9070 case 6243: return GET_LOOPS (6243);
9071 case 6300: return GET_LOOPS (6300);
9072 case 6400: return GET_LOOPS (6400);
9073 case 6500: return GET_LOOPS (6500);
9074 case 6600: return GET_LOOPS (6600);
9075 case 6700: return GET_LOOPS (6700);
9076 case 6800: return GET_LOOPS (6800);
9077 case 6900: return GET_LOOPS (6900);
9078 case 7100: return GET_LOOPS (7100);
9079 case 7200: return GET_LOOPS (7200);
9080 case 7300: return GET_LOOPS (7300);
9081 case 7400: return GET_LOOPS (7400);
9082 case 7500: return GET_LOOPS (7500);
9083 case 7600: return GET_LOOPS (7600);
9084 case 7700: return GET_LOOPS (7700);
9085 case 7800: return GET_LOOPS (7800);
9086 case 7900: return GET_LOOPS (7900);
9087 case 8000: return GET_LOOPS (8000);
9088 case 8100: return GET_LOOPS (8100);
9089 case 8200: return GET_LOOPS (8200);
9090 case 8300: return GET_LOOPS (8300);
9091 case 8400: return GET_LOOPS (8400);
9092 case 8500: return GET_LOOPS (8500);
9093 case 8600: return GET_LOOPS (8600);
9094 case 8700: return GET_LOOPS (8700);
9095 case 8800: return GET_LOOPS (8800);
9096 case 8900: return GET_LOOPS (8900);
9097 case 9000: return GET_LOOPS (9000);
9098 case 9100: return GET_LOOPS (9100);
9099 case 9200: return GET_LOOPS (9200);
9100 case 9300: return GET_LOOPS (9300);
9101 case 9400: return GET_LOOPS (9400);
9102 case 9500: return GET_LOOPS (9500);
9103 case 9600: return GET_LOOPS (9600);
9104 case 9700: return GET_LOOPS (9700);
9105 case 9710: return GET_LOOPS (9710);
9106 case 9720: return GET_LOOPS (9720);
9107 case 9800: return GET_LOOPS (9800);
9108 case 9810: return GET_LOOPS (9810);
9109 case 9820: return GET_LOOPS (9820);
9110 case 9900: return GET_LOOPS (9900);
9111 case 10000: return GET_LOOPS (10000);
9112 case 10100: return GET_LOOPS (10100);
9113 case 10200: return GET_LOOPS (10200);
9114 case 10300: return GET_LOOPS (10300);
9115 case 10400: return GET_LOOPS (10400);
9116 case 10410: return GET_LOOPS (10410);
9117 case 10420: return GET_LOOPS (10420);
9118 case 10500: return GET_LOOPS (10500);
9119 case 10600: return GET_LOOPS (10600);
9120 case 10700: return GET_LOOPS (10700);
9121 case 10800: return GET_LOOPS (10800);
9122 case 10900: return GET_LOOPS (10900);
9123 case 11000: return GET_LOOPS (11000);
9124 case 11100: return GET_LOOPS (11100);
9125 case 11200: return GET_LOOPS (11200);
9126 case 11300: return GET_LOOPS (11300);
9127 case 11400: return GET_LOOPS (11400);
9128 case 11500: return GET_LOOPS (11500);
9129 case 11600: return GET_LOOPS (11600);
9130 case 11700: return GET_LOOPS (11700);
9131 case 11800: return GET_LOOPS (11800);
9132 case 11900: return GET_LOOPS (11900);
9133 case 12000: return GET_LOOPS (12000);
9134 case 12100: return GET_LOOPS (12100);
9135 case 12200: return GET_LOOPS (12200);
9136 case 12300: return GET_LOOPS (12300);
9137 case 12400: return GET_LOOPS (12400);
9138 case 12500: return GET_LOOPS (12500);
9139 case 12600: return GET_LOOPS (12600);
9140 case 12700: return GET_LOOPS (12700);
9141 case 12800: return GET_LOOPS (12800);
9151 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9155 if (salt_len
> sizeof(tmp
))
9160 memset (tmp
, 0, sizeof (tmp
));
9161 memcpy (tmp
, in
, salt_len
);
9163 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9165 if ((salt_len
% 2) == 0)
9167 uint new_salt_len
= salt_len
/ 2;
9169 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9171 char p0
= tmp
[j
+ 0];
9172 char p1
= tmp
[j
+ 1];
9174 tmp
[i
] = hex_convert (p1
) << 0;
9175 tmp
[i
] |= hex_convert (p0
) << 4;
9178 salt_len
= new_salt_len
;
9185 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9187 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9190 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9192 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9196 uint
*tmp_uint
= (uint
*) tmp
;
9198 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9199 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9200 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9201 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9202 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9203 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9204 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9205 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9206 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9207 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9209 salt_len
= salt_len
* 2;
9217 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9219 lowercase (tmp
, salt_len
);
9222 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9224 uppercase (tmp
, salt_len
);
9227 uint len
= salt_len
;
9229 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9234 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9239 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9241 uint
*tmp_uint
= (uint
*) tmp
;
9247 for (uint i
= 0; i
< max
; i
++)
9249 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9252 // Important: we may need to increase the length of memcpy since
9253 // we don't want to "loose" some swapped bytes (could happen if
9254 // they do not perfectly fit in the 4-byte blocks)
9255 // Memcpy does always copy the bytes in the BE order, but since
9256 // we swapped them, some important bytes could be in positions
9257 // we normally skip with the original len
9259 if (len
% 4) len
+= 4 - (len
% 4);
9262 memcpy (out
, tmp
, len
);
9267 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9269 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9271 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9273 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9275 salt_t
*salt
= hash_buf
->salt
;
9277 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9279 char *iter_pos
= input_buf
+ 4;
9281 salt
->salt_iter
= 1 << atoi (iter_pos
);
9283 char *salt_pos
= strchr (iter_pos
, '$');
9285 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9291 salt
->salt_len
= salt_len
;
9295 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9297 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9299 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9301 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9303 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9304 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9305 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9306 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9308 char *hash_pos
= salt_pos
+ 22;
9310 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9312 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9314 memcpy (digest
, tmp_buf
, 24);
9316 digest
[0] = byte_swap_32 (digest
[0]);
9317 digest
[1] = byte_swap_32 (digest
[1]);
9318 digest
[2] = byte_swap_32 (digest
[2]);
9319 digest
[3] = byte_swap_32 (digest
[3]);
9320 digest
[4] = byte_swap_32 (digest
[4]);
9321 digest
[5] = byte_swap_32 (digest
[5]);
9323 digest
[5] &= ~0xff; // its just 23 not 24 !
9328 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9330 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9332 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9336 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9338 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9340 memcpy (digest
, tmp_buf
, 32);
9342 digest
[0] = byte_swap_32 (digest
[0]);
9343 digest
[1] = byte_swap_32 (digest
[1]);
9344 digest
[2] = byte_swap_32 (digest
[2]);
9345 digest
[3] = byte_swap_32 (digest
[3]);
9346 digest
[4] = byte_swap_32 (digest
[4]);
9347 digest
[5] = byte_swap_32 (digest
[5]);
9348 digest
[6] = byte_swap_32 (digest
[6]);
9349 digest
[7] = byte_swap_32 (digest
[7]);
9351 digest
[0] -= SHA256M_A
;
9352 digest
[1] -= SHA256M_B
;
9353 digest
[2] -= SHA256M_C
;
9354 digest
[3] -= SHA256M_D
;
9355 digest
[4] -= SHA256M_E
;
9356 digest
[5] -= SHA256M_F
;
9357 digest
[6] -= SHA256M_G
;
9358 digest
[7] -= SHA256M_H
;
9363 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9365 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9367 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9369 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9370 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9372 digest
[0] = byte_swap_32 (digest
[0]);
9373 digest
[1] = byte_swap_32 (digest
[1]);
9377 IP (digest
[0], digest
[1], tt
);
9379 digest
[0] = digest
[0];
9380 digest
[1] = digest
[1];
9387 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9389 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9391 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9393 salt_t
*salt
= hash_buf
->salt
;
9395 char *hash_pos
= input_buf
+ 8;
9397 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9398 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9399 digest
[2] = hex_to_uint (&hash_pos
[16]);
9400 digest
[3] = hex_to_uint (&hash_pos
[24]);
9401 digest
[4] = hex_to_uint (&hash_pos
[32]);
9403 digest
[0] -= SHA1M_A
;
9404 digest
[1] -= SHA1M_B
;
9405 digest
[2] -= SHA1M_C
;
9406 digest
[3] -= SHA1M_D
;
9407 digest
[4] -= SHA1M_E
;
9411 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9413 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9415 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9417 salt
->salt_len
= salt_len
;
9422 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9424 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9426 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9428 salt_t
*salt
= hash_buf
->salt
;
9430 char *hash_pos
= input_buf
+ 8;
9432 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9433 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9434 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9435 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9436 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9437 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9438 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9439 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9441 digest
[0] -= SHA512M_A
;
9442 digest
[1] -= SHA512M_B
;
9443 digest
[2] -= SHA512M_C
;
9444 digest
[3] -= SHA512M_D
;
9445 digest
[4] -= SHA512M_E
;
9446 digest
[5] -= SHA512M_F
;
9447 digest
[6] -= SHA512M_G
;
9448 digest
[7] -= SHA512M_H
;
9452 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9454 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9456 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9458 salt
->salt_len
= salt_len
;
9463 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9465 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9467 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9471 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9474 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9476 salt_t
*salt
= hash_buf
->salt
;
9478 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9479 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9480 digest
[2] = hex_to_uint (&input_buf
[16]);
9481 digest
[3] = hex_to_uint (&input_buf
[24]);
9483 digest
[0] = byte_swap_32 (digest
[0]);
9484 digest
[1] = byte_swap_32 (digest
[1]);
9485 digest
[2] = byte_swap_32 (digest
[2]);
9486 digest
[3] = byte_swap_32 (digest
[3]);
9488 digest
[0] -= MD5M_A
;
9489 digest
[1] -= MD5M_B
;
9490 digest
[2] -= MD5M_C
;
9491 digest
[3] -= MD5M_D
;
9493 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9495 uint salt_len
= input_len
- 32 - 1;
9497 char *salt_buf
= input_buf
+ 32 + 1;
9499 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9501 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9503 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9505 salt
->salt_len
= salt_len
;
9510 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9512 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9514 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9518 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9523 char clean_input_buf
[32];
9525 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9526 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9528 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9532 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9538 clean_input_buf
[k
] = input_buf
[i
];
9546 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9548 salt_t
*salt
= hash_buf
->salt
;
9550 char a
, b
, c
, d
, e
, f
;
9552 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9553 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9554 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9555 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9556 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9557 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9559 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9560 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9562 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9563 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9564 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9565 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9566 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9567 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9569 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9570 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9572 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9573 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9574 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9575 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9576 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9577 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9579 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9580 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9582 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9583 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9584 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9585 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9586 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9587 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9589 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9590 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9592 digest
[0] = byte_swap_32 (digest
[0]);
9593 digest
[1] = byte_swap_32 (digest
[1]);
9594 digest
[2] = byte_swap_32 (digest
[2]);
9595 digest
[3] = byte_swap_32 (digest
[3]);
9597 digest
[0] -= MD5M_A
;
9598 digest
[1] -= MD5M_B
;
9599 digest
[2] -= MD5M_C
;
9600 digest
[3] -= MD5M_D
;
9602 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9604 uint salt_len
= input_len
- 30 - 1;
9606 char *salt_buf
= input_buf
+ 30 + 1;
9608 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9610 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9612 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9614 salt
->salt_len
= salt_len
;
9616 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9618 salt
->salt_len
+= 22;
9623 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9625 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9627 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9631 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9634 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9636 salt_t
*salt
= hash_buf
->salt
;
9638 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9639 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9640 digest
[2] = hex_to_uint (&input_buf
[16]);
9641 digest
[3] = hex_to_uint (&input_buf
[24]);
9642 digest
[4] = hex_to_uint (&input_buf
[32]);
9644 digest
[0] -= SHA1M_A
;
9645 digest
[1] -= SHA1M_B
;
9646 digest
[2] -= SHA1M_C
;
9647 digest
[3] -= SHA1M_D
;
9648 digest
[4] -= SHA1M_E
;
9650 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9652 uint salt_len
= input_len
- 40 - 1;
9654 char *salt_buf
= input_buf
+ 40 + 1;
9656 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9658 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9660 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9662 salt
->salt_len
= salt_len
;
9667 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9669 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9671 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9675 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9678 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9680 char *iter_pos
= input_buf
+ 6;
9682 salt_t
*salt
= hash_buf
->salt
;
9684 salt
->salt_iter
= atoi (iter_pos
) - 1;
9686 char *salt_pos
= strchr (iter_pos
, '#');
9688 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9692 char *digest_pos
= strchr (salt_pos
, '#');
9694 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9698 uint salt_len
= digest_pos
- salt_pos
- 1;
9700 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9702 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9703 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9704 digest
[2] = hex_to_uint (&digest_pos
[16]);
9705 digest
[3] = hex_to_uint (&digest_pos
[24]);
9707 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9709 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9711 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9713 salt
->salt_len
= salt_len
;
9718 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9720 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9722 salt_t
*salt
= hash_buf
->salt
;
9724 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9728 memcpy (&in
, input_buf
, input_len
);
9730 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9732 memcpy (digest
, in
.keymic
, 16);
9735 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9736 The phrase "Pairwise key expansion"
9737 Access Point Address (Referred to as Authenticator Address AA)
9738 Supplicant Address (referred to as Supplicant Address SA)
9739 Access Point Nonce (referred to as Authenticator Anonce)
9740 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9743 uint salt_len
= strlen (in
.essid
);
9745 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9747 salt
->salt_len
= salt_len
;
9749 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9751 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9753 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9755 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9757 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9758 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9762 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9763 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9766 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9768 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9769 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9773 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9774 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9777 for (int i
= 0; i
< 25; i
++)
9779 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9782 wpa
->keyver
= in
.keyver
;
9784 if (wpa
->keyver
> 255)
9786 log_info ("ATTENTION!");
9787 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9788 log_info (" This could be due to a recent aircrack-ng bug.");
9789 log_info (" The key version was automatically reset to a reasonable value.");
9792 wpa
->keyver
&= 0xff;
9795 wpa
->eapol_size
= in
.eapol_size
;
9797 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9799 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9801 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9803 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9805 if (wpa
->keyver
== 1)
9811 digest
[0] = byte_swap_32 (digest
[0]);
9812 digest
[1] = byte_swap_32 (digest
[1]);
9813 digest
[2] = byte_swap_32 (digest
[2]);
9814 digest
[3] = byte_swap_32 (digest
[3]);
9816 for (int i
= 0; i
< 64; i
++)
9818 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9822 salt
->salt_buf
[10] = digest
[1];
9823 salt
->salt_buf
[11] = digest
[2];
9828 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9830 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9832 salt_t
*salt
= hash_buf
->salt
;
9836 log_error ("Password Safe v2 container not specified");
9841 FILE *fp
= fopen (input_buf
, "rb");
9845 log_error ("%s: %s", input_buf
, strerror (errno
));
9854 uint32_t salt
[5]; // unused, but makes better valid check
9855 uint32_t iv
[2]; // unused, but makes better valid check
9861 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9865 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9867 salt
->salt_buf
[0] = buf
.random
[0];
9868 salt
->salt_buf
[1] = buf
.random
[1];
9871 salt
->salt_iter
= 1000;
9873 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9874 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9875 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9876 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9877 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9882 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9884 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9886 salt_t
*salt
= hash_buf
->salt
;
9890 log_error (".psafe3 not specified");
9895 FILE *fp
= fopen (input_buf
, "rb");
9899 log_error ("%s: %s", input_buf
, strerror (errno
));
9906 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9910 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9912 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9914 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9916 salt
->salt_iter
= in
.iterations
+ 1;
9918 salt
->salt_buf
[0] = in
.salt_buf
[0];
9919 salt
->salt_buf
[1] = in
.salt_buf
[1];
9920 salt
->salt_buf
[2] = in
.salt_buf
[2];
9921 salt
->salt_buf
[3] = in
.salt_buf
[3];
9922 salt
->salt_buf
[4] = in
.salt_buf
[4];
9923 salt
->salt_buf
[5] = in
.salt_buf
[5];
9924 salt
->salt_buf
[6] = in
.salt_buf
[6];
9925 salt
->salt_buf
[7] = in
.salt_buf
[7];
9927 salt
->salt_len
= 32;
9929 digest
[0] = in
.hash_buf
[0];
9930 digest
[1] = in
.hash_buf
[1];
9931 digest
[2] = in
.hash_buf
[2];
9932 digest
[3] = in
.hash_buf
[3];
9933 digest
[4] = in
.hash_buf
[4];
9934 digest
[5] = in
.hash_buf
[5];
9935 digest
[6] = in
.hash_buf
[6];
9936 digest
[7] = in
.hash_buf
[7];
9938 digest
[0] = byte_swap_32 (digest
[0]);
9939 digest
[1] = byte_swap_32 (digest
[1]);
9940 digest
[2] = byte_swap_32 (digest
[2]);
9941 digest
[3] = byte_swap_32 (digest
[3]);
9942 digest
[4] = byte_swap_32 (digest
[4]);
9943 digest
[5] = byte_swap_32 (digest
[5]);
9944 digest
[6] = byte_swap_32 (digest
[6]);
9945 digest
[7] = byte_swap_32 (digest
[7]);
9950 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9952 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
9954 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
9956 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9958 salt_t
*salt
= hash_buf
->salt
;
9960 char *iter_pos
= input_buf
+ 3;
9962 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
9964 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
9966 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
9968 salt
->salt_iter
= salt_iter
;
9970 char *salt_pos
= iter_pos
+ 1;
9974 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
9976 salt
->salt_len
= salt_len
;
9978 char *hash_pos
= salt_pos
+ salt_len
;
9980 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
9985 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9987 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
9989 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9991 salt_t
*salt
= hash_buf
->salt
;
9993 char *salt_pos
= input_buf
+ 3;
9995 uint iterations_len
= 0;
9997 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10001 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10003 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10004 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10008 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10012 iterations_len
+= 8;
10016 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10019 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10021 char *hash_pos
= strchr (salt_pos
, '$');
10023 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10025 uint salt_len
= hash_pos
- salt_pos
;
10027 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10029 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10031 salt
->salt_len
= salt_len
;
10035 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10037 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10039 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10041 return (PARSER_OK
);
10044 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10046 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10048 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10050 salt_t
*salt
= hash_buf
->salt
;
10052 char *salt_pos
= input_buf
+ 6;
10054 uint iterations_len
= 0;
10056 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10060 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10062 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10063 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10067 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10071 iterations_len
+= 8;
10075 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10078 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10080 char *hash_pos
= strchr (salt_pos
, '$');
10082 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10084 uint salt_len
= hash_pos
- salt_pos
;
10086 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10088 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10090 salt
->salt_len
= salt_len
;
10094 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10096 return (PARSER_OK
);
10099 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10101 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10103 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10105 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10107 salt_t
*salt
= hash_buf
->salt
;
10109 char *salt_pos
= input_buf
+ 14;
10111 char *hash_pos
= strchr (salt_pos
, '*');
10113 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10117 uint salt_len
= hash_pos
- salt_pos
- 1;
10119 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10121 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10123 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10125 salt
->salt_len
= salt_len
;
10127 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10129 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10131 memcpy (digest
, tmp_buf
, 20);
10133 digest
[0] = byte_swap_32 (digest
[0]);
10134 digest
[1] = byte_swap_32 (digest
[1]);
10135 digest
[2] = byte_swap_32 (digest
[2]);
10136 digest
[3] = byte_swap_32 (digest
[3]);
10137 digest
[4] = byte_swap_32 (digest
[4]);
10139 digest
[0] -= SHA1M_A
;
10140 digest
[1] -= SHA1M_B
;
10141 digest
[2] -= SHA1M_C
;
10142 digest
[3] -= SHA1M_D
;
10143 digest
[4] -= SHA1M_E
;
10145 return (PARSER_OK
);
10148 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10150 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10152 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10154 if (c12
& 3) return (PARSER_HASH_VALUE
);
10156 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10158 salt_t
*salt
= hash_buf
->salt
;
10160 // for ascii_digest
10161 salt
->salt_sign
[0] = input_buf
[0];
10162 salt
->salt_sign
[1] = input_buf
[1];
10164 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10165 | itoa64_to_int (input_buf
[1]) << 6;
10167 salt
->salt_len
= 2;
10171 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10173 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10175 memcpy (digest
, tmp_buf
, 8);
10179 IP (digest
[0], digest
[1], tt
);
10184 return (PARSER_OK
);
10187 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10189 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10191 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10193 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10194 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10195 digest
[2] = hex_to_uint (&input_buf
[16]);
10196 digest
[3] = hex_to_uint (&input_buf
[24]);
10198 digest
[0] = byte_swap_32 (digest
[0]);
10199 digest
[1] = byte_swap_32 (digest
[1]);
10200 digest
[2] = byte_swap_32 (digest
[2]);
10201 digest
[3] = byte_swap_32 (digest
[3]);
10203 digest
[0] -= MD4M_A
;
10204 digest
[1] -= MD4M_B
;
10205 digest
[2] -= MD4M_C
;
10206 digest
[3] -= MD4M_D
;
10208 return (PARSER_OK
);
10211 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10213 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10215 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10219 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10222 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10224 salt_t
*salt
= hash_buf
->salt
;
10226 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10227 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10228 digest
[2] = hex_to_uint (&input_buf
[16]);
10229 digest
[3] = hex_to_uint (&input_buf
[24]);
10231 digest
[0] = byte_swap_32 (digest
[0]);
10232 digest
[1] = byte_swap_32 (digest
[1]);
10233 digest
[2] = byte_swap_32 (digest
[2]);
10234 digest
[3] = byte_swap_32 (digest
[3]);
10236 digest
[0] -= MD4M_A
;
10237 digest
[1] -= MD4M_B
;
10238 digest
[2] -= MD4M_C
;
10239 digest
[3] -= MD4M_D
;
10241 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10243 uint salt_len
= input_len
- 32 - 1;
10245 char *salt_buf
= input_buf
+ 32 + 1;
10247 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10249 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10251 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10253 salt
->salt_len
= salt_len
;
10255 return (PARSER_OK
);
10258 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10260 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10262 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10264 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10265 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10266 digest
[2] = hex_to_uint (&input_buf
[16]);
10267 digest
[3] = hex_to_uint (&input_buf
[24]);
10269 digest
[0] = byte_swap_32 (digest
[0]);
10270 digest
[1] = byte_swap_32 (digest
[1]);
10271 digest
[2] = byte_swap_32 (digest
[2]);
10272 digest
[3] = byte_swap_32 (digest
[3]);
10274 digest
[0] -= MD5M_A
;
10275 digest
[1] -= MD5M_B
;
10276 digest
[2] -= MD5M_C
;
10277 digest
[3] -= MD5M_D
;
10279 return (PARSER_OK
);
10282 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10284 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10286 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10288 digest
[0] = hex_to_uint (&input_buf
[0]);
10289 digest
[1] = hex_to_uint (&input_buf
[8]);
10293 digest
[0] = byte_swap_32 (digest
[0]);
10294 digest
[1] = byte_swap_32 (digest
[1]);
10296 return (PARSER_OK
);
10299 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10301 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10303 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10307 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10310 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10312 salt_t
*salt
= hash_buf
->salt
;
10314 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10315 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10316 digest
[2] = hex_to_uint (&input_buf
[16]);
10317 digest
[3] = hex_to_uint (&input_buf
[24]);
10319 digest
[0] = byte_swap_32 (digest
[0]);
10320 digest
[1] = byte_swap_32 (digest
[1]);
10321 digest
[2] = byte_swap_32 (digest
[2]);
10322 digest
[3] = byte_swap_32 (digest
[3]);
10324 digest
[0] -= MD5M_A
;
10325 digest
[1] -= MD5M_B
;
10326 digest
[2] -= MD5M_C
;
10327 digest
[3] -= MD5M_D
;
10329 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10331 uint salt_len
= input_len
- 32 - 1;
10333 char *salt_buf
= input_buf
+ 32 + 1;
10335 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10337 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10339 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10341 salt
->salt_len
= salt_len
;
10343 return (PARSER_OK
);
10346 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10348 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10350 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10352 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10353 | itoa64_to_int (input_buf
[ 1]) << 6
10354 | itoa64_to_int (input_buf
[ 2]) << 12
10355 | itoa64_to_int (input_buf
[ 3]) << 18;
10356 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10357 | itoa64_to_int (input_buf
[ 5]) << 6
10358 | itoa64_to_int (input_buf
[ 6]) << 12
10359 | itoa64_to_int (input_buf
[ 7]) << 18;
10360 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10361 | itoa64_to_int (input_buf
[ 9]) << 6
10362 | itoa64_to_int (input_buf
[10]) << 12
10363 | itoa64_to_int (input_buf
[11]) << 18;
10364 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10365 | itoa64_to_int (input_buf
[13]) << 6
10366 | itoa64_to_int (input_buf
[14]) << 12
10367 | itoa64_to_int (input_buf
[15]) << 18;
10369 digest
[0] -= MD5M_A
;
10370 digest
[1] -= MD5M_B
;
10371 digest
[2] -= MD5M_C
;
10372 digest
[3] -= MD5M_D
;
10374 digest
[0] &= 0x00ffffff;
10375 digest
[1] &= 0x00ffffff;
10376 digest
[2] &= 0x00ffffff;
10377 digest
[3] &= 0x00ffffff;
10379 return (PARSER_OK
);
10382 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10384 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10386 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10390 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10393 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10395 salt_t
*salt
= hash_buf
->salt
;
10397 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10398 | itoa64_to_int (input_buf
[ 1]) << 6
10399 | itoa64_to_int (input_buf
[ 2]) << 12
10400 | itoa64_to_int (input_buf
[ 3]) << 18;
10401 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10402 | itoa64_to_int (input_buf
[ 5]) << 6
10403 | itoa64_to_int (input_buf
[ 6]) << 12
10404 | itoa64_to_int (input_buf
[ 7]) << 18;
10405 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10406 | itoa64_to_int (input_buf
[ 9]) << 6
10407 | itoa64_to_int (input_buf
[10]) << 12
10408 | itoa64_to_int (input_buf
[11]) << 18;
10409 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10410 | itoa64_to_int (input_buf
[13]) << 6
10411 | itoa64_to_int (input_buf
[14]) << 12
10412 | itoa64_to_int (input_buf
[15]) << 18;
10414 digest
[0] -= MD5M_A
;
10415 digest
[1] -= MD5M_B
;
10416 digest
[2] -= MD5M_C
;
10417 digest
[3] -= MD5M_D
;
10419 digest
[0] &= 0x00ffffff;
10420 digest
[1] &= 0x00ffffff;
10421 digest
[2] &= 0x00ffffff;
10422 digest
[3] &= 0x00ffffff;
10424 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10426 uint salt_len
= input_len
- 16 - 1;
10428 char *salt_buf
= input_buf
+ 16 + 1;
10430 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10432 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10434 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10436 salt
->salt_len
= salt_len
;
10438 return (PARSER_OK
);
10441 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10443 key
[0] = (nthash
[0] >> 0);
10444 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10445 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10446 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10447 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10448 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10449 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10450 key
[7] = (nthash
[6] << 1);
10462 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10464 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10466 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10468 salt_t
*salt
= hash_buf
->salt
;
10470 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10476 char *user_pos
= input_buf
;
10478 char *unused_pos
= strchr (user_pos
, ':');
10480 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10482 uint user_len
= unused_pos
- user_pos
;
10484 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10488 char *domain_pos
= strchr (unused_pos
, ':');
10490 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10492 uint unused_len
= domain_pos
- unused_pos
;
10494 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10498 char *srvchall_pos
= strchr (domain_pos
, ':');
10500 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10502 uint domain_len
= srvchall_pos
- domain_pos
;
10504 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10508 char *hash_pos
= strchr (srvchall_pos
, ':');
10510 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10512 uint srvchall_len
= hash_pos
- srvchall_pos
;
10514 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10518 char *clichall_pos
= strchr (hash_pos
, ':');
10520 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10522 uint hash_len
= clichall_pos
- hash_pos
;
10524 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10528 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10530 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10533 * store some data for later use
10536 netntlm
->user_len
= user_len
* 2;
10537 netntlm
->domain_len
= domain_len
* 2;
10538 netntlm
->srvchall_len
= srvchall_len
/ 2;
10539 netntlm
->clichall_len
= clichall_len
/ 2;
10541 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10542 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10545 * handle username and domainname
10548 for (uint i
= 0; i
< user_len
; i
++)
10550 *userdomain_ptr
++ = user_pos
[i
];
10551 *userdomain_ptr
++ = 0;
10554 for (uint i
= 0; i
< domain_len
; i
++)
10556 *userdomain_ptr
++ = domain_pos
[i
];
10557 *userdomain_ptr
++ = 0;
10561 * handle server challenge encoding
10564 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10566 const char p0
= srvchall_pos
[i
+ 0];
10567 const char p1
= srvchall_pos
[i
+ 1];
10569 *chall_ptr
++ = hex_convert (p1
) << 0
10570 | hex_convert (p0
) << 4;
10574 * handle client challenge encoding
10577 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10579 const char p0
= clichall_pos
[i
+ 0];
10580 const char p1
= clichall_pos
[i
+ 1];
10582 *chall_ptr
++ = hex_convert (p1
) << 0
10583 | hex_convert (p0
) << 4;
10590 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10592 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10594 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10596 salt
->salt_len
= salt_len
;
10598 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10599 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10600 digest
[2] = hex_to_uint (&hash_pos
[16]);
10601 digest
[3] = hex_to_uint (&hash_pos
[24]);
10603 digest
[0] = byte_swap_32 (digest
[0]);
10604 digest
[1] = byte_swap_32 (digest
[1]);
10605 digest
[2] = byte_swap_32 (digest
[2]);
10606 digest
[3] = byte_swap_32 (digest
[3]);
10608 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10610 uint digest_tmp
[2];
10612 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10613 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10615 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10616 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10618 /* special case 2: ESS */
10620 if (srvchall_len
== 48)
10622 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10626 w
[ 0] = netntlm
->chall_buf
[6];
10627 w
[ 1] = netntlm
->chall_buf
[7];
10628 w
[ 2] = netntlm
->chall_buf
[0];
10629 w
[ 3] = netntlm
->chall_buf
[1];
10652 salt
->salt_buf
[0] = dgst
[0];
10653 salt
->salt_buf
[1] = dgst
[1];
10657 /* precompute netntlmv1 exploit start */
10659 for (uint i
= 0; i
< 0x10000; i
++)
10661 uint key_md4
[2] = { i
, 0 };
10662 uint key_des
[2] = { 0, 0 };
10664 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10669 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10671 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10673 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10675 if (data3
[0] != digest_tmp
[0]) continue;
10676 if (data3
[1] != digest_tmp
[1]) continue;
10678 salt
->salt_buf
[2] = i
;
10680 salt
->salt_len
= 24;
10685 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10686 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10688 /* precompute netntlmv1 exploit stop */
10692 IP (digest
[0], digest
[1], tt
);
10693 IP (digest
[2], digest
[3], tt
);
10695 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10696 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10697 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10698 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10700 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10702 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10703 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10705 return (PARSER_OK
);
10708 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10710 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10712 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10714 salt_t
*salt
= hash_buf
->salt
;
10716 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10722 char *user_pos
= input_buf
;
10724 char *unused_pos
= strchr (user_pos
, ':');
10726 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10728 uint user_len
= unused_pos
- user_pos
;
10730 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10734 char *domain_pos
= strchr (unused_pos
, ':');
10736 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10738 uint unused_len
= domain_pos
- unused_pos
;
10740 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10744 char *srvchall_pos
= strchr (domain_pos
, ':');
10746 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10748 uint domain_len
= srvchall_pos
- domain_pos
;
10750 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10754 char *hash_pos
= strchr (srvchall_pos
, ':');
10756 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10758 uint srvchall_len
= hash_pos
- srvchall_pos
;
10760 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10764 char *clichall_pos
= strchr (hash_pos
, ':');
10766 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10768 uint hash_len
= clichall_pos
- hash_pos
;
10770 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10774 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10776 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10778 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10781 * store some data for later use
10784 netntlm
->user_len
= user_len
* 2;
10785 netntlm
->domain_len
= domain_len
* 2;
10786 netntlm
->srvchall_len
= srvchall_len
/ 2;
10787 netntlm
->clichall_len
= clichall_len
/ 2;
10789 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10790 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10793 * handle username and domainname
10796 for (uint i
= 0; i
< user_len
; i
++)
10798 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10799 *userdomain_ptr
++ = 0;
10802 for (uint i
= 0; i
< domain_len
; i
++)
10804 *userdomain_ptr
++ = domain_pos
[i
];
10805 *userdomain_ptr
++ = 0;
10808 *userdomain_ptr
++ = 0x80;
10811 * handle server challenge encoding
10814 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10816 const char p0
= srvchall_pos
[i
+ 0];
10817 const char p1
= srvchall_pos
[i
+ 1];
10819 *chall_ptr
++ = hex_convert (p1
) << 0
10820 | hex_convert (p0
) << 4;
10824 * handle client challenge encoding
10827 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10829 const char p0
= clichall_pos
[i
+ 0];
10830 const char p1
= clichall_pos
[i
+ 1];
10832 *chall_ptr
++ = hex_convert (p1
) << 0
10833 | hex_convert (p0
) << 4;
10836 *chall_ptr
++ = 0x80;
10839 * handle hash itself
10842 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10843 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10844 digest
[2] = hex_to_uint (&hash_pos
[16]);
10845 digest
[3] = hex_to_uint (&hash_pos
[24]);
10847 digest
[0] = byte_swap_32 (digest
[0]);
10848 digest
[1] = byte_swap_32 (digest
[1]);
10849 digest
[2] = byte_swap_32 (digest
[2]);
10850 digest
[3] = byte_swap_32 (digest
[3]);
10853 * reuse challange data as salt_buf, its the buffer that is most likely unique
10856 salt
->salt_buf
[0] = 0;
10857 salt
->salt_buf
[1] = 0;
10858 salt
->salt_buf
[2] = 0;
10859 salt
->salt_buf
[3] = 0;
10860 salt
->salt_buf
[4] = 0;
10861 salt
->salt_buf
[5] = 0;
10862 salt
->salt_buf
[6] = 0;
10863 salt
->salt_buf
[7] = 0;
10867 uptr
= (uint
*) netntlm
->userdomain_buf
;
10869 for (uint i
= 0; i
< 16; i
+= 16)
10871 md5_64 (uptr
, salt
->salt_buf
);
10874 uptr
= (uint
*) netntlm
->chall_buf
;
10876 for (uint i
= 0; i
< 256; i
+= 16)
10878 md5_64 (uptr
, salt
->salt_buf
);
10881 salt
->salt_len
= 16;
10883 return (PARSER_OK
);
10886 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10888 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10890 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10894 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10897 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10899 salt_t
*salt
= hash_buf
->salt
;
10901 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10902 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10903 digest
[2] = hex_to_uint (&input_buf
[16]);
10904 digest
[3] = hex_to_uint (&input_buf
[24]);
10906 digest
[0] = byte_swap_32 (digest
[0]);
10907 digest
[1] = byte_swap_32 (digest
[1]);
10908 digest
[2] = byte_swap_32 (digest
[2]);
10909 digest
[3] = byte_swap_32 (digest
[3]);
10911 digest
[0] -= MD5M_A
;
10912 digest
[1] -= MD5M_B
;
10913 digest
[2] -= MD5M_C
;
10914 digest
[3] -= MD5M_D
;
10916 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10918 uint salt_len
= input_len
- 32 - 1;
10920 char *salt_buf
= input_buf
+ 32 + 1;
10922 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10924 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10926 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10928 salt
->salt_len
= salt_len
;
10930 return (PARSER_OK
);
10933 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10935 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10937 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10941 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
10944 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10946 salt_t
*salt
= hash_buf
->salt
;
10948 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10949 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10950 digest
[2] = hex_to_uint (&input_buf
[16]);
10951 digest
[3] = hex_to_uint (&input_buf
[24]);
10953 digest
[0] = byte_swap_32 (digest
[0]);
10954 digest
[1] = byte_swap_32 (digest
[1]);
10955 digest
[2] = byte_swap_32 (digest
[2]);
10956 digest
[3] = byte_swap_32 (digest
[3]);
10958 digest
[0] -= MD5M_A
;
10959 digest
[1] -= MD5M_B
;
10960 digest
[2] -= MD5M_C
;
10961 digest
[3] -= MD5M_D
;
10963 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10965 uint salt_len
= input_len
- 32 - 1;
10967 char *salt_buf
= input_buf
+ 32 + 1;
10969 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10971 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10973 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10975 salt
->salt_len
= salt_len
;
10977 return (PARSER_OK
);
10980 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10982 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
10984 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10986 salt_t
*salt
= hash_buf
->salt
;
10988 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10989 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10990 digest
[2] = hex_to_uint (&input_buf
[16]);
10991 digest
[3] = hex_to_uint (&input_buf
[24]);
10993 digest
[0] = byte_swap_32 (digest
[0]);
10994 digest
[1] = byte_swap_32 (digest
[1]);
10995 digest
[2] = byte_swap_32 (digest
[2]);
10996 digest
[3] = byte_swap_32 (digest
[3]);
10998 digest
[0] -= MD5M_A
;
10999 digest
[1] -= MD5M_B
;
11000 digest
[2] -= MD5M_C
;
11001 digest
[3] -= MD5M_D
;
11004 * This is a virtual salt. While the algorithm is basically not salted
11005 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11006 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11009 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11011 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11013 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11015 salt
->salt_len
= salt_len
;
11017 return (PARSER_OK
);
11020 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11022 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11024 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11028 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11031 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11033 salt_t
*salt
= hash_buf
->salt
;
11035 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11036 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11037 digest
[2] = hex_to_uint (&input_buf
[16]);
11038 digest
[3] = hex_to_uint (&input_buf
[24]);
11040 digest
[0] = byte_swap_32 (digest
[0]);
11041 digest
[1] = byte_swap_32 (digest
[1]);
11042 digest
[2] = byte_swap_32 (digest
[2]);
11043 digest
[3] = byte_swap_32 (digest
[3]);
11045 digest
[0] -= MD5M_A
;
11046 digest
[1] -= MD5M_B
;
11047 digest
[2] -= MD5M_C
;
11048 digest
[3] -= MD5M_D
;
11050 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11052 uint salt_len
= input_len
- 32 - 1;
11054 char *salt_buf
= input_buf
+ 32 + 1;
11056 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11058 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11060 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11062 salt
->salt_len
= salt_len
;
11064 return (PARSER_OK
);
11067 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11069 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11071 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11075 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11078 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11080 salt_t
*salt
= hash_buf
->salt
;
11082 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11083 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11084 digest
[2] = hex_to_uint (&input_buf
[16]);
11085 digest
[3] = hex_to_uint (&input_buf
[24]);
11087 digest
[0] = byte_swap_32 (digest
[0]);
11088 digest
[1] = byte_swap_32 (digest
[1]);
11089 digest
[2] = byte_swap_32 (digest
[2]);
11090 digest
[3] = byte_swap_32 (digest
[3]);
11092 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11094 uint salt_len
= input_len
- 32 - 1;
11096 char *salt_buf
= input_buf
+ 32 + 1;
11098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11104 salt
->salt_len
= salt_len
;
11106 return (PARSER_OK
);
11109 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11111 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11113 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11117 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11120 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11122 salt_t
*salt
= hash_buf
->salt
;
11124 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11125 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11126 digest
[2] = hex_to_uint (&input_buf
[16]);
11127 digest
[3] = hex_to_uint (&input_buf
[24]);
11129 digest
[0] = byte_swap_32 (digest
[0]);
11130 digest
[1] = byte_swap_32 (digest
[1]);
11131 digest
[2] = byte_swap_32 (digest
[2]);
11132 digest
[3] = byte_swap_32 (digest
[3]);
11134 digest
[0] -= MD4M_A
;
11135 digest
[1] -= MD4M_B
;
11136 digest
[2] -= MD4M_C
;
11137 digest
[3] -= MD4M_D
;
11139 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11141 uint salt_len
= input_len
- 32 - 1;
11143 char *salt_buf
= input_buf
+ 32 + 1;
11145 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11151 salt
->salt_len
= salt_len
;
11153 return (PARSER_OK
);
11156 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11158 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11160 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11164 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11167 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11169 salt_t
*salt
= hash_buf
->salt
;
11171 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11172 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11173 digest
[2] = hex_to_uint (&input_buf
[16]);
11174 digest
[3] = hex_to_uint (&input_buf
[24]);
11176 digest
[0] = byte_swap_32 (digest
[0]);
11177 digest
[1] = byte_swap_32 (digest
[1]);
11178 digest
[2] = byte_swap_32 (digest
[2]);
11179 digest
[3] = byte_swap_32 (digest
[3]);
11181 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11183 uint salt_len
= input_len
- 32 - 1;
11185 char *salt_buf
= input_buf
+ 32 + 1;
11187 uint salt_pc_block
[16];
11189 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11191 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11193 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11195 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11197 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11199 salt_pc_block
[14] = salt_len
* 8;
11201 uint salt_pc_digest
[4];
11203 salt_pc_digest
[0] = MAGIC_A
;
11204 salt_pc_digest
[1] = MAGIC_B
;
11205 salt_pc_digest
[2] = MAGIC_C
;
11206 salt_pc_digest
[3] = MAGIC_D
;
11208 md5_64 (salt_pc_block
, salt_pc_digest
);
11210 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11211 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11212 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11213 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11215 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11217 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11219 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11221 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11222 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11223 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11224 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11226 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11228 return (PARSER_OK
);
11231 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11233 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11235 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11237 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11238 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11239 digest
[2] = hex_to_uint (&input_buf
[16]);
11240 digest
[3] = hex_to_uint (&input_buf
[24]);
11241 digest
[4] = hex_to_uint (&input_buf
[32]);
11243 digest
[0] -= SHA1M_A
;
11244 digest
[1] -= SHA1M_B
;
11245 digest
[2] -= SHA1M_C
;
11246 digest
[3] -= SHA1M_D
;
11247 digest
[4] -= SHA1M_E
;
11249 return (PARSER_OK
);
11252 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11254 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11256 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11258 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11259 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11260 digest
[2] = hex_to_uint (&input_buf
[16]);
11261 digest
[3] = hex_to_uint (&input_buf
[24]);
11262 digest
[4] = hex_to_uint (&input_buf
[32]);
11264 return (PARSER_OK
);
11267 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11269 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11271 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11275 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11278 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11280 salt_t
*salt
= hash_buf
->salt
;
11282 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11283 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11284 digest
[2] = hex_to_uint (&input_buf
[16]);
11285 digest
[3] = hex_to_uint (&input_buf
[24]);
11286 digest
[4] = hex_to_uint (&input_buf
[32]);
11288 digest
[0] -= SHA1M_A
;
11289 digest
[1] -= SHA1M_B
;
11290 digest
[2] -= SHA1M_C
;
11291 digest
[3] -= SHA1M_D
;
11292 digest
[4] -= SHA1M_E
;
11294 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11296 uint salt_len
= input_len
- 40 - 1;
11298 char *salt_buf
= input_buf
+ 40 + 1;
11300 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11302 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11304 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11306 salt
->salt_len
= salt_len
;
11308 return (PARSER_OK
);
11311 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11313 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11315 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11317 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11321 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11323 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11325 memcpy (digest
, tmp_buf
, 20);
11327 digest
[0] = byte_swap_32 (digest
[0]);
11328 digest
[1] = byte_swap_32 (digest
[1]);
11329 digest
[2] = byte_swap_32 (digest
[2]);
11330 digest
[3] = byte_swap_32 (digest
[3]);
11331 digest
[4] = byte_swap_32 (digest
[4]);
11333 digest
[0] -= SHA1M_A
;
11334 digest
[1] -= SHA1M_B
;
11335 digest
[2] -= SHA1M_C
;
11336 digest
[3] -= SHA1M_D
;
11337 digest
[4] -= SHA1M_E
;
11339 return (PARSER_OK
);
11342 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11344 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11346 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11348 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11350 salt_t
*salt
= hash_buf
->salt
;
11354 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11356 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11358 memcpy (digest
, tmp_buf
, 20);
11360 salt
->salt_len
= tmp_len
- 20;
11362 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11364 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11366 char *ptr
= (char *) salt
->salt_buf
;
11368 ptr
[salt
->salt_len
] = 0x80;
11371 digest
[0] = byte_swap_32 (digest
[0]);
11372 digest
[1] = byte_swap_32 (digest
[1]);
11373 digest
[2] = byte_swap_32 (digest
[2]);
11374 digest
[3] = byte_swap_32 (digest
[3]);
11375 digest
[4] = byte_swap_32 (digest
[4]);
11377 digest
[0] -= SHA1M_A
;
11378 digest
[1] -= SHA1M_B
;
11379 digest
[2] -= SHA1M_C
;
11380 digest
[3] -= SHA1M_D
;
11381 digest
[4] -= SHA1M_E
;
11383 return (PARSER_OK
);
11386 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11388 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11390 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11392 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11394 salt_t
*salt
= hash_buf
->salt
;
11396 char *salt_buf
= input_buf
+ 6;
11400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11402 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11404 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11406 salt
->salt_len
= salt_len
;
11408 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11410 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11411 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11412 digest
[2] = hex_to_uint (&hash_pos
[16]);
11413 digest
[3] = hex_to_uint (&hash_pos
[24]);
11414 digest
[4] = hex_to_uint (&hash_pos
[32]);
11416 digest
[0] -= SHA1M_A
;
11417 digest
[1] -= SHA1M_B
;
11418 digest
[2] -= SHA1M_C
;
11419 digest
[3] -= SHA1M_D
;
11420 digest
[4] -= SHA1M_E
;
11422 return (PARSER_OK
);
11425 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11427 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11429 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11431 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11433 salt_t
*salt
= hash_buf
->salt
;
11435 char *salt_buf
= input_buf
+ 6;
11439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11441 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11443 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11445 salt
->salt_len
= salt_len
;
11447 char *hash_pos
= input_buf
+ 6 + 8;
11449 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11450 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11451 digest
[2] = hex_to_uint (&hash_pos
[16]);
11452 digest
[3] = hex_to_uint (&hash_pos
[24]);
11453 digest
[4] = hex_to_uint (&hash_pos
[32]);
11455 digest
[0] -= SHA1M_A
;
11456 digest
[1] -= SHA1M_B
;
11457 digest
[2] -= SHA1M_C
;
11458 digest
[3] -= SHA1M_D
;
11459 digest
[4] -= SHA1M_E
;
11461 return (PARSER_OK
);
11464 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11466 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11468 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11470 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11472 salt_t
*salt
= hash_buf
->salt
;
11474 char *salt_buf
= input_buf
+ 6;
11478 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11480 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11482 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11484 salt
->salt_len
= salt_len
;
11486 char *hash_pos
= input_buf
+ 6 + 8;
11488 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11489 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11490 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11491 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11492 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11493 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11494 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11495 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11497 digest
[0] -= SHA512M_A
;
11498 digest
[1] -= SHA512M_B
;
11499 digest
[2] -= SHA512M_C
;
11500 digest
[3] -= SHA512M_D
;
11501 digest
[4] -= SHA512M_E
;
11502 digest
[5] -= SHA512M_F
;
11503 digest
[6] -= SHA512M_G
;
11504 digest
[7] -= SHA512M_H
;
11506 return (PARSER_OK
);
11509 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11511 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11513 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11517 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11520 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11522 salt_t
*salt
= hash_buf
->salt
;
11524 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11525 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11529 digest
[0] = byte_swap_32 (digest
[0]);
11530 digest
[1] = byte_swap_32 (digest
[1]);
11532 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11534 uint salt_len
= input_len
- 16 - 1;
11536 char *salt_buf
= input_buf
+ 16 + 1;
11538 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11540 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11542 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11544 salt
->salt_len
= salt_len
;
11546 return (PARSER_OK
);
11549 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11551 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11553 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11555 salt_t
*salt
= hash_buf
->salt
;
11557 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11558 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11559 digest
[2] = hex_to_uint (&input_buf
[16]);
11560 digest
[3] = hex_to_uint (&input_buf
[24]);
11561 digest
[4] = hex_to_uint (&input_buf
[32]);
11563 digest
[0] -= SHA1M_A
;
11564 digest
[1] -= SHA1M_B
;
11565 digest
[2] -= SHA1M_C
;
11566 digest
[3] -= SHA1M_D
;
11567 digest
[4] -= SHA1M_E
;
11569 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11571 uint salt_len
= input_len
- 40 - 1;
11573 char *salt_buf
= input_buf
+ 40 + 1;
11575 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11577 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11579 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11581 salt
->salt_len
= salt_len
;
11583 return (PARSER_OK
);
11586 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11588 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11590 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11592 salt_t
*salt
= hash_buf
->salt
;
11594 char *hash_pos
= input_buf
;
11596 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11597 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11598 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11599 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11600 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11601 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11602 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11603 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11604 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11605 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11606 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11607 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11608 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11609 digest
[13] = hex_to_uint (&hash_pos
[104]);
11610 digest
[14] = hex_to_uint (&hash_pos
[112]);
11611 digest
[15] = hex_to_uint (&hash_pos
[120]);
11613 char *salt_pos
= input_buf
+ 128;
11615 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11616 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11617 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11618 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11620 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11621 salt
->salt_len
= 16;
11623 return (PARSER_OK
);
11626 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11628 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11630 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11632 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11633 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11634 digest
[2] = hex_to_uint (&input_buf
[16]);
11635 digest
[3] = hex_to_uint (&input_buf
[24]);
11636 digest
[4] = hex_to_uint (&input_buf
[32]);
11637 digest
[5] = hex_to_uint (&input_buf
[40]);
11638 digest
[6] = hex_to_uint (&input_buf
[48]);
11639 digest
[7] = hex_to_uint (&input_buf
[56]);
11641 digest
[0] -= SHA256M_A
;
11642 digest
[1] -= SHA256M_B
;
11643 digest
[2] -= SHA256M_C
;
11644 digest
[3] -= SHA256M_D
;
11645 digest
[4] -= SHA256M_E
;
11646 digest
[5] -= SHA256M_F
;
11647 digest
[6] -= SHA256M_G
;
11648 digest
[7] -= SHA256M_H
;
11650 return (PARSER_OK
);
11653 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11655 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11657 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11661 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11664 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11666 salt_t
*salt
= hash_buf
->salt
;
11668 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11669 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11670 digest
[2] = hex_to_uint (&input_buf
[16]);
11671 digest
[3] = hex_to_uint (&input_buf
[24]);
11672 digest
[4] = hex_to_uint (&input_buf
[32]);
11673 digest
[5] = hex_to_uint (&input_buf
[40]);
11674 digest
[6] = hex_to_uint (&input_buf
[48]);
11675 digest
[7] = hex_to_uint (&input_buf
[56]);
11677 digest
[0] -= SHA256M_A
;
11678 digest
[1] -= SHA256M_B
;
11679 digest
[2] -= SHA256M_C
;
11680 digest
[3] -= SHA256M_D
;
11681 digest
[4] -= SHA256M_E
;
11682 digest
[5] -= SHA256M_F
;
11683 digest
[6] -= SHA256M_G
;
11684 digest
[7] -= SHA256M_H
;
11686 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11688 uint salt_len
= input_len
- 64 - 1;
11690 char *salt_buf
= input_buf
+ 64 + 1;
11692 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11694 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11696 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11698 salt
->salt_len
= salt_len
;
11700 return (PARSER_OK
);
11703 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11705 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11707 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11709 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11710 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11711 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11712 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11713 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11714 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11718 digest
[0] -= SHA384M_A
;
11719 digest
[1] -= SHA384M_B
;
11720 digest
[2] -= SHA384M_C
;
11721 digest
[3] -= SHA384M_D
;
11722 digest
[4] -= SHA384M_E
;
11723 digest
[5] -= SHA384M_F
;
11727 return (PARSER_OK
);
11730 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11732 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11734 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11736 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11737 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11738 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11739 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11740 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11741 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11742 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11743 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11745 digest
[0] -= SHA512M_A
;
11746 digest
[1] -= SHA512M_B
;
11747 digest
[2] -= SHA512M_C
;
11748 digest
[3] -= SHA512M_D
;
11749 digest
[4] -= SHA512M_E
;
11750 digest
[5] -= SHA512M_F
;
11751 digest
[6] -= SHA512M_G
;
11752 digest
[7] -= SHA512M_H
;
11754 return (PARSER_OK
);
11757 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11759 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11761 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11765 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11768 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11770 salt_t
*salt
= hash_buf
->salt
;
11772 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11773 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11774 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11775 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11776 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11777 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11778 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11779 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11781 digest
[0] -= SHA512M_A
;
11782 digest
[1] -= SHA512M_B
;
11783 digest
[2] -= SHA512M_C
;
11784 digest
[3] -= SHA512M_D
;
11785 digest
[4] -= SHA512M_E
;
11786 digest
[5] -= SHA512M_F
;
11787 digest
[6] -= SHA512M_G
;
11788 digest
[7] -= SHA512M_H
;
11790 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11792 uint salt_len
= input_len
- 128 - 1;
11794 char *salt_buf
= input_buf
+ 128 + 1;
11796 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11798 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11800 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11802 salt
->salt_len
= salt_len
;
11804 return (PARSER_OK
);
11807 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11809 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11811 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11813 salt_t
*salt
= hash_buf
->salt
;
11815 char *salt_pos
= input_buf
+ 3;
11817 uint iterations_len
= 0;
11819 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11823 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11825 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11826 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11830 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11834 iterations_len
+= 8;
11838 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11841 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11843 char *hash_pos
= strchr (salt_pos
, '$');
11845 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11847 uint salt_len
= hash_pos
- salt_pos
;
11849 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11851 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11853 salt
->salt_len
= salt_len
;
11857 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11859 return (PARSER_OK
);
11862 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11864 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11866 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11868 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11870 salt_t
*salt
= hash_buf
->salt
;
11872 uint keccak_mdlen
= input_len
/ 2;
11874 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11876 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11878 digest
[i
] = byte_swap_64 (digest
[i
]);
11881 salt
->keccak_mdlen
= keccak_mdlen
;
11883 return (PARSER_OK
);
11886 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11888 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11890 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11892 salt_t
*salt
= hash_buf
->salt
;
11894 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11897 * Parse that strange long line
11904 in_off
[0] = strtok (input_buf
, ":");
11906 in_len
[0] = strlen (in_off
[0]);
11910 for (i
= 1; i
< 9; i
++)
11912 in_off
[i
] = strtok (NULL
, ":");
11914 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11916 in_len
[i
] = strlen (in_off
[i
]);
11921 ptr
= (char *) ikepsk
->msg_buf
;
11923 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11924 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11925 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11926 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11927 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11928 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11932 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11934 ptr
= (char *) ikepsk
->nr_buf
;
11936 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11937 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11941 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
11944 * Store to database
11949 digest
[0] = hex_to_uint (&ptr
[ 0]);
11950 digest
[1] = hex_to_uint (&ptr
[ 8]);
11951 digest
[2] = hex_to_uint (&ptr
[16]);
11952 digest
[3] = hex_to_uint (&ptr
[24]);
11954 digest
[0] = byte_swap_32 (digest
[0]);
11955 digest
[1] = byte_swap_32 (digest
[1]);
11956 digest
[2] = byte_swap_32 (digest
[2]);
11957 digest
[3] = byte_swap_32 (digest
[3]);
11959 salt
->salt_len
= 32;
11961 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
11962 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
11963 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
11964 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
11965 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
11966 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
11967 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
11968 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
11970 return (PARSER_OK
);
11973 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11975 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
11977 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11979 salt_t
*salt
= hash_buf
->salt
;
11981 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11984 * Parse that strange long line
11991 in_off
[0] = strtok (input_buf
, ":");
11993 in_len
[0] = strlen (in_off
[0]);
11997 for (i
= 1; i
< 9; i
++)
11999 in_off
[i
] = strtok (NULL
, ":");
12001 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12003 in_len
[i
] = strlen (in_off
[i
]);
12008 ptr
= (char *) ikepsk
->msg_buf
;
12010 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12011 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12012 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12013 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12014 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12015 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12019 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12021 ptr
= (char *) ikepsk
->nr_buf
;
12023 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12024 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12028 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12031 * Store to database
12036 digest
[0] = hex_to_uint (&ptr
[ 0]);
12037 digest
[1] = hex_to_uint (&ptr
[ 8]);
12038 digest
[2] = hex_to_uint (&ptr
[16]);
12039 digest
[3] = hex_to_uint (&ptr
[24]);
12040 digest
[4] = hex_to_uint (&ptr
[32]);
12042 salt
->salt_len
= 32;
12044 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12045 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12046 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12047 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12048 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12049 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12050 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12051 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12053 return (PARSER_OK
);
12056 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12058 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12060 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12062 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12063 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12064 digest
[2] = hex_to_uint (&input_buf
[16]);
12065 digest
[3] = hex_to_uint (&input_buf
[24]);
12066 digest
[4] = hex_to_uint (&input_buf
[32]);
12068 digest
[0] = byte_swap_32 (digest
[0]);
12069 digest
[1] = byte_swap_32 (digest
[1]);
12070 digest
[2] = byte_swap_32 (digest
[2]);
12071 digest
[3] = byte_swap_32 (digest
[3]);
12072 digest
[4] = byte_swap_32 (digest
[4]);
12074 return (PARSER_OK
);
12077 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12079 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12081 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12083 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12084 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12085 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12086 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12087 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12088 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12089 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12090 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12091 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12092 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12093 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12094 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12095 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12096 digest
[13] = hex_to_uint (&input_buf
[104]);
12097 digest
[14] = hex_to_uint (&input_buf
[112]);
12098 digest
[15] = hex_to_uint (&input_buf
[120]);
12100 return (PARSER_OK
);
12103 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12105 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12107 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12109 salt_t
*salt
= hash_buf
->salt
;
12111 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12112 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12113 digest
[2] = hex_to_uint (&input_buf
[16]);
12114 digest
[3] = hex_to_uint (&input_buf
[24]);
12115 digest
[4] = hex_to_uint (&input_buf
[32]);
12117 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12119 uint salt_len
= input_len
- 40 - 1;
12121 char *salt_buf
= input_buf
+ 40 + 1;
12123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12125 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12127 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12129 salt
->salt_len
= salt_len
;
12131 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12133 return (PARSER_OK
);
12136 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12138 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12140 salt_t
*salt
= hash_buf
->salt
;
12142 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12144 if (input_len
== 0)
12146 log_error ("TrueCrypt container not specified");
12151 FILE *fp
= fopen (input_buf
, "rb");
12155 log_error ("%s: %s", input_buf
, strerror (errno
));
12162 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12166 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12168 memcpy (tc
->salt_buf
, buf
, 64);
12170 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12172 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12174 salt
->salt_len
= 4;
12176 salt
->salt_iter
= 1000 - 1;
12178 digest
[0] = tc
->data_buf
[0];
12180 return (PARSER_OK
);
12183 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12185 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12187 salt_t
*salt
= hash_buf
->salt
;
12189 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12191 if (input_len
== 0)
12193 log_error ("TrueCrypt container not specified");
12198 FILE *fp
= fopen (input_buf
, "rb");
12202 log_error ("%s: %s", input_buf
, strerror (errno
));
12209 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12213 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12215 memcpy (tc
->salt_buf
, buf
, 64);
12217 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12219 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12221 salt
->salt_len
= 4;
12223 salt
->salt_iter
= 2000 - 1;
12225 digest
[0] = tc
->data_buf
[0];
12227 return (PARSER_OK
);
12230 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12232 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12234 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12236 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12238 salt_t
*salt
= hash_buf
->salt
;
12240 char *salt_pos
= input_buf
+ 6;
12242 char *hash_pos
= strchr (salt_pos
, '$');
12244 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12246 uint salt_len
= hash_pos
- salt_pos
;
12248 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12250 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12252 salt
->salt_len
= salt_len
;
12254 salt
->salt_iter
= 1000;
12258 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12260 return (PARSER_OK
);
12263 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12265 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12267 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12269 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12271 salt_t
*salt
= hash_buf
->salt
;
12273 char *iter_pos
= input_buf
+ 7;
12275 char *salt_pos
= strchr (iter_pos
, '$');
12277 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12281 char *hash_pos
= strchr (salt_pos
, '$');
12283 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12285 uint salt_len
= hash_pos
- salt_pos
;
12287 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12289 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12291 salt
->salt_len
= salt_len
;
12293 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12295 salt
->salt_sign
[0] = atoi (salt_iter
);
12297 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12301 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12303 digest
[0] = byte_swap_32 (digest
[0]);
12304 digest
[1] = byte_swap_32 (digest
[1]);
12305 digest
[2] = byte_swap_32 (digest
[2]);
12306 digest
[3] = byte_swap_32 (digest
[3]);
12307 digest
[4] = byte_swap_32 (digest
[4]);
12309 return (PARSER_OK
);
12312 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12314 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12316 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12318 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12320 salt_t
*salt
= hash_buf
->salt
;
12322 char *iter_pos
= input_buf
+ 9;
12324 char *salt_pos
= strchr (iter_pos
, '$');
12326 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12330 char *hash_pos
= strchr (salt_pos
, '$');
12332 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12334 uint salt_len
= hash_pos
- salt_pos
;
12336 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12338 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12340 salt
->salt_len
= salt_len
;
12342 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12344 salt
->salt_sign
[0] = atoi (salt_iter
);
12346 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12350 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12352 digest
[0] = byte_swap_32 (digest
[0]);
12353 digest
[1] = byte_swap_32 (digest
[1]);
12354 digest
[2] = byte_swap_32 (digest
[2]);
12355 digest
[3] = byte_swap_32 (digest
[3]);
12356 digest
[4] = byte_swap_32 (digest
[4]);
12357 digest
[5] = byte_swap_32 (digest
[5]);
12358 digest
[6] = byte_swap_32 (digest
[6]);
12359 digest
[7] = byte_swap_32 (digest
[7]);
12361 return (PARSER_OK
);
12364 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12366 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12368 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12370 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12372 salt_t
*salt
= hash_buf
->salt
;
12374 char *iter_pos
= input_buf
+ 9;
12376 char *salt_pos
= strchr (iter_pos
, '$');
12378 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12382 char *hash_pos
= strchr (salt_pos
, '$');
12384 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12386 uint salt_len
= hash_pos
- salt_pos
;
12388 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12390 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12392 salt
->salt_len
= salt_len
;
12394 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12396 salt
->salt_sign
[0] = atoi (salt_iter
);
12398 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12402 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12404 digest
[0] = byte_swap_64 (digest
[0]);
12405 digest
[1] = byte_swap_64 (digest
[1]);
12406 digest
[2] = byte_swap_64 (digest
[2]);
12407 digest
[3] = byte_swap_64 (digest
[3]);
12408 digest
[4] = byte_swap_64 (digest
[4]);
12409 digest
[5] = byte_swap_64 (digest
[5]);
12410 digest
[6] = byte_swap_64 (digest
[6]);
12411 digest
[7] = byte_swap_64 (digest
[7]);
12413 return (PARSER_OK
);
12416 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12418 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12420 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12422 salt_t
*salt
= hash_buf
->salt
;
12424 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12430 char *iterations_pos
= input_buf
;
12432 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12434 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12436 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12438 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12442 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12444 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12446 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12448 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12450 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12452 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12457 * pbkdf2 iterations
12460 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12463 * handle salt encoding
12466 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12468 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12470 const char p0
= saltbuf_pos
[i
+ 0];
12471 const char p1
= saltbuf_pos
[i
+ 1];
12473 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12474 | hex_convert (p0
) << 4;
12477 salt
->salt_len
= saltbuf_len
/ 2;
12480 * handle cipher encoding
12483 uint
*tmp
= (uint
*) mymalloc (32);
12485 char *cipherbuf_ptr
= (char *) tmp
;
12487 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12489 const char p0
= cipherbuf_pos
[i
+ 0];
12490 const char p1
= cipherbuf_pos
[i
+ 1];
12492 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12493 | hex_convert (p0
) << 4;
12496 // iv is stored at salt_buf 4 (length 16)
12497 // data is stored at salt_buf 8 (length 16)
12499 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12500 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12501 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12502 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12504 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12505 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12506 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12507 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12511 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12513 const char p0
= cipherbuf_pos
[j
+ 0];
12514 const char p1
= cipherbuf_pos
[j
+ 1];
12516 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12517 | hex_convert (p0
) << 4;
12524 digest
[0] = 0x10101010;
12525 digest
[1] = 0x10101010;
12526 digest
[2] = 0x10101010;
12527 digest
[3] = 0x10101010;
12529 return (PARSER_OK
);
12532 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12534 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12536 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12538 salt_t
*salt
= hash_buf
->salt
;
12540 char *hashbuf_pos
= input_buf
;
12542 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12544 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12546 uint hash_len
= iterations_pos
- hashbuf_pos
;
12548 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12552 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12554 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12556 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12560 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12562 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12564 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12566 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12568 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12570 salt
->salt_len
= salt_len
;
12572 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12574 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12575 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12576 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12577 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12579 return (PARSER_OK
);
12582 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12584 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12586 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12588 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12589 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12590 digest
[2] = hex_to_uint (&input_buf
[16]);
12591 digest
[3] = hex_to_uint (&input_buf
[24]);
12592 digest
[4] = hex_to_uint (&input_buf
[32]);
12593 digest
[5] = hex_to_uint (&input_buf
[40]);
12594 digest
[6] = hex_to_uint (&input_buf
[48]);
12595 digest
[7] = hex_to_uint (&input_buf
[56]);
12597 digest
[0] = byte_swap_32 (digest
[0]);
12598 digest
[1] = byte_swap_32 (digest
[1]);
12599 digest
[2] = byte_swap_32 (digest
[2]);
12600 digest
[3] = byte_swap_32 (digest
[3]);
12601 digest
[4] = byte_swap_32 (digest
[4]);
12602 digest
[5] = byte_swap_32 (digest
[5]);
12603 digest
[6] = byte_swap_32 (digest
[6]);
12604 digest
[7] = byte_swap_32 (digest
[7]);
12606 return (PARSER_OK
);
12609 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12611 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12613 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12615 salt_t
*salt
= hash_buf
->salt
;
12617 char *salt_pos
= input_buf
+ 3;
12619 uint iterations_len
= 0;
12621 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12625 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12627 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12628 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12632 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12636 iterations_len
+= 8;
12640 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12643 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12645 char *hash_pos
= strchr (salt_pos
, '$');
12647 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12649 uint salt_len
= hash_pos
- salt_pos
;
12651 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12653 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12655 salt
->salt_len
= salt_len
;
12659 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12661 return (PARSER_OK
);
12664 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12666 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12668 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12670 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12672 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12674 salt_t
*salt
= hash_buf
->salt
;
12676 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12678 char *iter_pos
= input_buf
+ 4;
12680 char *salt_pos
= strchr (iter_pos
, '$');
12682 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12686 char *hash_pos
= strchr (salt_pos
, '$');
12688 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12690 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12694 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12695 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12696 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12697 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12698 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12699 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12700 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12701 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12703 uint salt_len
= hash_pos
- salt_pos
- 1;
12705 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12707 salt
->salt_len
= salt_len
/ 2;
12709 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12710 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12711 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12712 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12713 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12714 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12715 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12716 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12718 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12719 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12720 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12721 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12722 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12723 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12724 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12725 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12726 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12727 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12729 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12731 salt
->salt_iter
= atoi (iter_pos
) - 1;
12733 return (PARSER_OK
);
12736 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12738 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12740 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12742 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12744 salt_t
*salt
= hash_buf
->salt
;
12746 char *salt_pos
= input_buf
+ 14;
12748 char *hash_pos
= strchr (salt_pos
, '*');
12750 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12754 uint salt_len
= hash_pos
- salt_pos
- 1;
12756 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12758 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12760 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12762 salt
->salt_len
= salt_len
;
12764 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12766 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12768 memcpy (digest
, tmp_buf
, 32);
12770 digest
[0] = byte_swap_32 (digest
[0]);
12771 digest
[1] = byte_swap_32 (digest
[1]);
12772 digest
[2] = byte_swap_32 (digest
[2]);
12773 digest
[3] = byte_swap_32 (digest
[3]);
12774 digest
[4] = byte_swap_32 (digest
[4]);
12775 digest
[5] = byte_swap_32 (digest
[5]);
12776 digest
[6] = byte_swap_32 (digest
[6]);
12777 digest
[7] = byte_swap_32 (digest
[7]);
12779 digest
[0] -= SHA256M_A
;
12780 digest
[1] -= SHA256M_B
;
12781 digest
[2] -= SHA256M_C
;
12782 digest
[3] -= SHA256M_D
;
12783 digest
[4] -= SHA256M_E
;
12784 digest
[5] -= SHA256M_F
;
12785 digest
[6] -= SHA256M_G
;
12786 digest
[7] -= SHA256M_H
;
12788 return (PARSER_OK
);
12791 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12793 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12795 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12797 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12799 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12801 salt_t
*salt
= hash_buf
->salt
;
12803 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12805 char *iter_pos
= input_buf
+ 19;
12807 char *salt_pos
= strchr (iter_pos
, '.');
12809 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12813 char *hash_pos
= strchr (salt_pos
, '.');
12815 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12817 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12821 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12822 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12823 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12824 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12825 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12826 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12827 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12828 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12830 uint salt_len
= hash_pos
- salt_pos
- 1;
12834 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12838 for (i
= 0; i
< salt_len
; i
++)
12840 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12843 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12844 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12846 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12848 salt
->salt_len
= salt_len
;
12850 salt
->salt_iter
= atoi (iter_pos
) - 1;
12852 return (PARSER_OK
);
12855 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12857 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12859 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12861 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12863 salt_t
*salt
= hash_buf
->salt
;
12867 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12869 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12871 memcpy (digest
, tmp_buf
, 64);
12873 digest
[0] = byte_swap_64 (digest
[0]);
12874 digest
[1] = byte_swap_64 (digest
[1]);
12875 digest
[2] = byte_swap_64 (digest
[2]);
12876 digest
[3] = byte_swap_64 (digest
[3]);
12877 digest
[4] = byte_swap_64 (digest
[4]);
12878 digest
[5] = byte_swap_64 (digest
[5]);
12879 digest
[6] = byte_swap_64 (digest
[6]);
12880 digest
[7] = byte_swap_64 (digest
[7]);
12882 digest
[0] -= SHA512M_A
;
12883 digest
[1] -= SHA512M_B
;
12884 digest
[2] -= SHA512M_C
;
12885 digest
[3] -= SHA512M_D
;
12886 digest
[4] -= SHA512M_E
;
12887 digest
[5] -= SHA512M_F
;
12888 digest
[6] -= SHA512M_G
;
12889 digest
[7] -= SHA512M_H
;
12891 salt
->salt_len
= tmp_len
- 64;
12893 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12895 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12897 char *ptr
= (char *) salt
->salt_buf
;
12899 ptr
[salt
->salt_len
] = 0x80;
12902 return (PARSER_OK
);
12905 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12907 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12909 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12913 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12916 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12918 salt_t
*salt
= hash_buf
->salt
;
12920 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12921 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12922 digest
[2] = hex_to_uint (&input_buf
[16]);
12923 digest
[3] = hex_to_uint (&input_buf
[24]);
12925 digest
[0] = byte_swap_32 (digest
[0]);
12926 digest
[1] = byte_swap_32 (digest
[1]);
12927 digest
[2] = byte_swap_32 (digest
[2]);
12928 digest
[3] = byte_swap_32 (digest
[3]);
12930 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12932 uint salt_len
= input_len
- 32 - 1;
12934 char *salt_buf
= input_buf
+ 32 + 1;
12936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12938 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12940 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12942 salt
->salt_len
= salt_len
;
12944 return (PARSER_OK
);
12947 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12949 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12951 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
12955 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
12958 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12960 salt_t
*salt
= hash_buf
->salt
;
12962 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12963 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12964 digest
[2] = hex_to_uint (&input_buf
[16]);
12965 digest
[3] = hex_to_uint (&input_buf
[24]);
12966 digest
[4] = hex_to_uint (&input_buf
[32]);
12968 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12970 uint salt_len
= input_len
- 40 - 1;
12972 char *salt_buf
= input_buf
+ 40 + 1;
12974 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12976 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12978 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12980 salt
->salt_len
= salt_len
;
12982 return (PARSER_OK
);
12985 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12987 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12989 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
12993 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
12996 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12998 salt_t
*salt
= hash_buf
->salt
;
13000 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13001 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13002 digest
[2] = hex_to_uint (&input_buf
[16]);
13003 digest
[3] = hex_to_uint (&input_buf
[24]);
13004 digest
[4] = hex_to_uint (&input_buf
[32]);
13005 digest
[5] = hex_to_uint (&input_buf
[40]);
13006 digest
[6] = hex_to_uint (&input_buf
[48]);
13007 digest
[7] = hex_to_uint (&input_buf
[56]);
13009 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13011 uint salt_len
= input_len
- 64 - 1;
13013 char *salt_buf
= input_buf
+ 64 + 1;
13015 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13017 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13019 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13021 salt
->salt_len
= salt_len
;
13023 return (PARSER_OK
);
13026 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13028 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13030 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13034 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13037 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13039 salt_t
*salt
= hash_buf
->salt
;
13041 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13042 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13043 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13044 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13045 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13046 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13047 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13048 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13050 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13052 uint salt_len
= input_len
- 128 - 1;
13054 char *salt_buf
= input_buf
+ 128 + 1;
13056 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13058 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13060 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13062 salt
->salt_len
= salt_len
;
13064 return (PARSER_OK
);
13067 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13069 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13071 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13073 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13075 salt_t
*salt
= hash_buf
->salt
;
13077 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13083 char *user_pos
= input_buf
+ 10 + 1;
13085 char *realm_pos
= strchr (user_pos
, '$');
13087 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13089 uint user_len
= realm_pos
- user_pos
;
13091 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13095 char *salt_pos
= strchr (realm_pos
, '$');
13097 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13099 uint realm_len
= salt_pos
- realm_pos
;
13101 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13105 char *data_pos
= strchr (salt_pos
, '$');
13107 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13109 uint salt_len
= data_pos
- salt_pos
;
13111 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13115 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13117 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13123 memcpy (krb5pa
->user
, user_pos
, user_len
);
13124 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13125 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13127 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13129 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13131 const char p0
= data_pos
[i
+ 0];
13132 const char p1
= data_pos
[i
+ 1];
13134 *timestamp_ptr
++ = hex_convert (p1
) << 0
13135 | hex_convert (p0
) << 4;
13138 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13140 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13142 const char p0
= data_pos
[i
+ 0];
13143 const char p1
= data_pos
[i
+ 1];
13145 *checksum_ptr
++ = hex_convert (p1
) << 0
13146 | hex_convert (p0
) << 4;
13150 * copy some data to generic buffers to make sorting happy
13153 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13154 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13155 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13156 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13157 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13158 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13159 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13160 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13161 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13163 salt
->salt_len
= 36;
13165 digest
[0] = krb5pa
->checksum
[0];
13166 digest
[1] = krb5pa
->checksum
[1];
13167 digest
[2] = krb5pa
->checksum
[2];
13168 digest
[3] = krb5pa
->checksum
[3];
13170 return (PARSER_OK
);
13173 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13175 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13177 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13179 salt_t
*salt
= hash_buf
->salt
;
13185 char *salt_pos
= input_buf
;
13187 char *hash_pos
= strchr (salt_pos
, '$');
13189 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13191 uint salt_len
= hash_pos
- salt_pos
;
13193 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13197 uint hash_len
= input_len
- 1 - salt_len
;
13199 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13207 for (uint i
= 0; i
< salt_len
; i
++)
13209 if (salt_pos
[i
] == ' ') continue;
13214 // SAP user names cannot be longer than 12 characters
13215 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13217 // SAP user name cannot start with ! or ?
13218 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13224 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13226 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13228 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13230 salt
->salt_len
= salt_len
;
13232 digest
[0] = hex_to_uint (&hash_pos
[0]);
13233 digest
[1] = hex_to_uint (&hash_pos
[8]);
13237 digest
[0] = byte_swap_32 (digest
[0]);
13238 digest
[1] = byte_swap_32 (digest
[1]);
13240 return (PARSER_OK
);
13243 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13245 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13247 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13249 salt_t
*salt
= hash_buf
->salt
;
13255 char *salt_pos
= input_buf
;
13257 char *hash_pos
= strchr (salt_pos
, '$');
13259 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13261 uint salt_len
= hash_pos
- salt_pos
;
13263 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13267 uint hash_len
= input_len
- 1 - salt_len
;
13269 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13277 for (uint i
= 0; i
< salt_len
; i
++)
13279 if (salt_pos
[i
] == ' ') continue;
13284 // SAP user names cannot be longer than 12 characters
13285 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13287 // SAP user name cannot start with ! or ?
13288 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13294 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13296 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13298 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13300 salt
->salt_len
= salt_len
;
13302 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13303 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13304 digest
[2] = hex_to_uint (&hash_pos
[16]);
13305 digest
[3] = hex_to_uint (&hash_pos
[24]);
13306 digest
[4] = hex_to_uint (&hash_pos
[32]);
13308 return (PARSER_OK
);
13311 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13313 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13315 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13317 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13319 salt_t
*salt
= hash_buf
->salt
;
13321 char *iter_pos
= input_buf
+ 3;
13323 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13325 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13327 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13329 salt
->salt_iter
= salt_iter
;
13331 char *salt_pos
= iter_pos
+ 1;
13335 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13337 salt
->salt_len
= salt_len
;
13339 char *hash_pos
= salt_pos
+ salt_len
;
13341 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13345 char *tmp
= (char *) salt
->salt_buf_pc
;
13347 tmp
[0] = hash_pos
[42];
13351 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13352 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13353 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13354 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13360 return (PARSER_OK
);
13363 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13365 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13367 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13369 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13371 salt_t
*salt
= hash_buf
->salt
;
13373 char *salt_buf
= input_buf
+ 6;
13375 uint salt_len
= 16;
13377 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13379 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13381 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13383 salt
->salt_len
= salt_len
;
13385 char *hash_pos
= input_buf
+ 6 + 16;
13387 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13388 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13389 digest
[2] = hex_to_uint (&hash_pos
[16]);
13390 digest
[3] = hex_to_uint (&hash_pos
[24]);
13391 digest
[4] = hex_to_uint (&hash_pos
[32]);
13392 digest
[5] = hex_to_uint (&hash_pos
[40]);
13393 digest
[6] = hex_to_uint (&hash_pos
[48]);
13394 digest
[7] = hex_to_uint (&hash_pos
[56]);
13396 return (PARSER_OK
);
13399 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13401 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13403 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13405 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13406 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13410 return (PARSER_OK
);
13413 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13415 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13417 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13419 salt_t
*salt
= hash_buf
->salt
;
13421 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13423 char *saltbuf_pos
= input_buf
;
13425 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13427 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13429 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13431 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13432 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13434 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13438 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13440 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13442 char *salt_ptr
= (char *) saltbuf_pos
;
13443 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13448 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13450 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13453 rakp_ptr
[j
] = 0x80;
13455 rakp
->salt_len
= j
;
13457 for (i
= 0; i
< 64; i
++)
13459 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13462 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13463 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13464 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13465 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13466 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13467 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13468 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13469 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13471 salt
->salt_len
= 32; // muss min. 32 haben
13473 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13474 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13475 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13476 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13477 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13479 return (PARSER_OK
);
13482 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13484 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13486 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13488 salt_t
*salt
= hash_buf
->salt
;
13490 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13492 char *salt_pos
= input_buf
+ 1;
13494 memcpy (salt
->salt_buf
, salt_pos
, 8);
13496 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13497 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13499 salt
->salt_len
= 8;
13501 char *hash_pos
= salt_pos
+ 8;
13503 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13504 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13505 digest
[2] = hex_to_uint (&hash_pos
[16]);
13506 digest
[3] = hex_to_uint (&hash_pos
[24]);
13507 digest
[4] = hex_to_uint (&hash_pos
[32]);
13509 digest
[0] -= SHA1M_A
;
13510 digest
[1] -= SHA1M_B
;
13511 digest
[2] -= SHA1M_C
;
13512 digest
[3] -= SHA1M_D
;
13513 digest
[4] -= SHA1M_E
;
13515 return (PARSER_OK
);
13518 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13520 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13522 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13524 salt_t
*salt
= hash_buf
->salt
;
13526 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13527 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13528 digest
[2] = hex_to_uint (&input_buf
[16]);
13529 digest
[3] = hex_to_uint (&input_buf
[24]);
13531 digest
[0] = byte_swap_32 (digest
[0]);
13532 digest
[1] = byte_swap_32 (digest
[1]);
13533 digest
[2] = byte_swap_32 (digest
[2]);
13534 digest
[3] = byte_swap_32 (digest
[3]);
13536 digest
[0] -= MD5M_A
;
13537 digest
[1] -= MD5M_B
;
13538 digest
[2] -= MD5M_C
;
13539 digest
[3] -= MD5M_D
;
13541 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13543 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13545 uint32_t *salt_buf
= salt
->salt_buf
;
13547 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13548 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13549 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13550 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13552 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13553 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13554 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13555 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13557 salt
->salt_len
= 16 + 1;
13559 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13561 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13563 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13565 return (PARSER_OK
);
13568 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13570 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13572 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13574 salt_t
*salt
= hash_buf
->salt
;
13576 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13582 char *hashbuf_pos
= input_buf
;
13584 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13586 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13588 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13590 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13594 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13596 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13598 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13600 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13604 char *databuf_pos
= strchr (iteration_pos
, ':');
13606 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13608 const uint iteration_len
= databuf_pos
- iteration_pos
;
13610 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13611 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13613 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13615 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13616 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13622 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13623 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13624 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13625 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13626 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13627 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13628 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13629 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13633 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13635 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13637 const char p0
= saltbuf_pos
[i
+ 0];
13638 const char p1
= saltbuf_pos
[i
+ 1];
13640 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13641 | hex_convert (p0
) << 4;
13644 salt
->salt_buf
[4] = 0x01000000;
13645 salt
->salt_buf
[5] = 0x80;
13647 salt
->salt_len
= saltbuf_len
/ 2;
13651 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13655 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13657 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13659 const char p0
= databuf_pos
[i
+ 0];
13660 const char p1
= databuf_pos
[i
+ 1];
13662 *databuf_ptr
++ = hex_convert (p1
) << 0
13663 | hex_convert (p0
) << 4;
13666 *databuf_ptr
++ = 0x80;
13668 for (uint i
= 0; i
< 512; i
++)
13670 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13673 cloudkey
->data_len
= databuf_len
/ 2;
13675 return (PARSER_OK
);
13678 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13680 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13682 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13684 salt_t
*salt
= hash_buf
->salt
;
13690 char *hashbuf_pos
= input_buf
;
13692 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13694 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13696 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13698 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13702 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13704 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13706 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13708 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13710 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13714 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13716 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13718 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13720 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13722 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13726 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13728 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13729 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13731 // ok, the plan for this algorithm is the following:
13732 // we have 2 salts here, the domain-name and a random salt
13733 // while both are used in the initial transformation,
13734 // only the random salt is used in the following iterations
13735 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13736 // and one that includes only the real salt (stored into salt_buf[]).
13737 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13739 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13741 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13743 memcpy (digest
, tmp_buf
, 20);
13745 digest
[0] = byte_swap_32 (digest
[0]);
13746 digest
[1] = byte_swap_32 (digest
[1]);
13747 digest
[2] = byte_swap_32 (digest
[2]);
13748 digest
[3] = byte_swap_32 (digest
[3]);
13749 digest
[4] = byte_swap_32 (digest
[4]);
13753 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13755 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13757 char *len_ptr
= NULL
;
13759 for (uint i
= 0; i
< domainbuf_len
; i
++)
13761 if (salt_buf_pc_ptr
[i
] == '.')
13763 len_ptr
= &salt_buf_pc_ptr
[i
];
13773 salt
->salt_buf_pc
[7] = domainbuf_len
;
13777 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13779 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13781 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13783 salt
->salt_len
= salt_len
;
13787 salt
->salt_iter
= atoi (iteration_pos
);
13789 return (PARSER_OK
);
13792 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13794 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13796 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13798 salt_t
*salt
= hash_buf
->salt
;
13800 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13801 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13802 digest
[2] = hex_to_uint (&input_buf
[16]);
13803 digest
[3] = hex_to_uint (&input_buf
[24]);
13804 digest
[4] = hex_to_uint (&input_buf
[32]);
13806 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13808 uint salt_len
= input_len
- 40 - 1;
13810 char *salt_buf
= input_buf
+ 40 + 1;
13812 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13814 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13816 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13818 salt
->salt_len
= salt_len
;
13820 return (PARSER_OK
);
13823 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13825 const uint8_t ascii_to_ebcdic
[] =
13827 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13828 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13829 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13830 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13831 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13832 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13833 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13834 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13835 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13836 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13837 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13838 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13839 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13840 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13841 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13842 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13845 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13847 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13849 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13851 salt_t
*salt
= hash_buf
->salt
;
13853 char *salt_pos
= input_buf
+ 6 + 1;
13855 char *digest_pos
= strchr (salt_pos
, '*');
13857 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13859 uint salt_len
= digest_pos
- salt_pos
;
13861 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13863 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13865 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13870 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13872 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13874 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13876 salt
->salt_len
= salt_len
;
13878 for (uint i
= 0; i
< salt_len
; i
++)
13880 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13882 for (uint i
= salt_len
; i
< 8; i
++)
13884 salt_buf_pc_ptr
[i
] = 0x40;
13889 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13891 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13892 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13894 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13895 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13897 digest
[0] = byte_swap_32 (digest
[0]);
13898 digest
[1] = byte_swap_32 (digest
[1]);
13900 IP (digest
[0], digest
[1], tt
);
13902 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13903 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13907 return (PARSER_OK
);
13910 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13912 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13914 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13916 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13917 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13918 digest
[2] = hex_to_uint (&input_buf
[16]);
13919 digest
[3] = hex_to_uint (&input_buf
[24]);
13921 digest
[0] = byte_swap_32 (digest
[0]);
13922 digest
[1] = byte_swap_32 (digest
[1]);
13923 digest
[2] = byte_swap_32 (digest
[2]);
13924 digest
[3] = byte_swap_32 (digest
[3]);
13926 return (PARSER_OK
);
13929 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13931 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13933 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13935 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13937 salt_t
*salt
= hash_buf
->salt
;
13941 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13943 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13945 tmp_buf
[3] += -4; // dont ask!
13947 memcpy (salt
->salt_buf
, tmp_buf
, 5);
13949 salt
->salt_len
= 5;
13951 memcpy (digest
, tmp_buf
+ 5, 9);
13953 // yes, only 9 byte are needed to crack, but 10 to display
13955 salt
->salt_buf_pc
[7] = input_buf
[20];
13957 return (PARSER_OK
);
13960 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13962 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
13964 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13966 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13968 salt_t
*salt
= hash_buf
->salt
;
13972 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13974 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13976 tmp_buf
[3] += -4; // dont ask!
13980 memcpy (salt
->salt_buf
, tmp_buf
, 16);
13982 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)
13986 char tmp_iter_buf
[11];
13988 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
13990 tmp_iter_buf
[10] = 0;
13992 salt
->salt_iter
= atoi (tmp_iter_buf
);
13994 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
13996 return (PARSER_SALT_ITERATION
);
13999 salt
->salt_iter
--; // first round in init
14001 // 2 additional bytes for display only
14003 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14004 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14008 memcpy (digest
, tmp_buf
+ 28, 8);
14010 digest
[0] = byte_swap_32 (digest
[0]);
14011 digest
[1] = byte_swap_32 (digest
[1]);
14015 return (PARSER_OK
);
14018 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14020 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14022 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14024 salt_t
*salt
= hash_buf
->salt
;
14026 char *salt_buf_pos
= input_buf
;
14028 char *hash_buf_pos
= salt_buf_pos
+ 6;
14030 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14031 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14032 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14033 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14034 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14035 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14036 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14037 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14039 digest
[0] -= SHA256M_A
;
14040 digest
[1] -= SHA256M_B
;
14041 digest
[2] -= SHA256M_C
;
14042 digest
[3] -= SHA256M_D
;
14043 digest
[4] -= SHA256M_E
;
14044 digest
[5] -= SHA256M_F
;
14045 digest
[6] -= SHA256M_G
;
14046 digest
[7] -= SHA256M_H
;
14048 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14050 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14052 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14054 salt
->salt_len
= salt_len
;
14056 return (PARSER_OK
);
14059 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14061 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14063 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14065 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14067 salt_t
*salt
= hash_buf
->salt
;
14069 char *salt_buf
= input_buf
+ 6;
14071 char *digest_buf
= strchr (salt_buf
, '$');
14073 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14075 uint salt_len
= digest_buf
- salt_buf
;
14077 digest_buf
++; // skip the '$' symbol
14079 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14081 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14083 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14085 salt
->salt_len
= salt_len
;
14087 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14088 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14089 digest
[2] = hex_to_uint (&digest_buf
[16]);
14090 digest
[3] = hex_to_uint (&digest_buf
[24]);
14092 digest
[0] = byte_swap_32 (digest
[0]);
14093 digest
[1] = byte_swap_32 (digest
[1]);
14094 digest
[2] = byte_swap_32 (digest
[2]);
14095 digest
[3] = byte_swap_32 (digest
[3]);
14097 digest
[0] -= MD5M_A
;
14098 digest
[1] -= MD5M_B
;
14099 digest
[2] -= MD5M_C
;
14100 digest
[3] -= MD5M_D
;
14102 return (PARSER_OK
);
14105 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14107 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14109 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14111 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14113 salt_t
*salt
= hash_buf
->salt
;
14115 char *salt_buf
= input_buf
+ 3;
14117 char *digest_buf
= strchr (salt_buf
, '$');
14119 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14121 uint salt_len
= digest_buf
- salt_buf
;
14123 digest_buf
++; // skip the '$' symbol
14125 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14127 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14129 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14131 salt_buf_ptr
[salt_len
] = 0x2d;
14133 salt
->salt_len
= salt_len
+ 1;
14135 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14136 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14137 digest
[2] = hex_to_uint (&digest_buf
[16]);
14138 digest
[3] = hex_to_uint (&digest_buf
[24]);
14140 digest
[0] = byte_swap_32 (digest
[0]);
14141 digest
[1] = byte_swap_32 (digest
[1]);
14142 digest
[2] = byte_swap_32 (digest
[2]);
14143 digest
[3] = byte_swap_32 (digest
[3]);
14145 digest
[0] -= MD5M_A
;
14146 digest
[1] -= MD5M_B
;
14147 digest
[2] -= MD5M_C
;
14148 digest
[3] -= MD5M_D
;
14150 return (PARSER_OK
);
14153 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14155 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14157 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14161 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14163 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14165 memcpy (digest
, tmp_buf
, 20);
14167 digest
[0] = byte_swap_32 (digest
[0]);
14168 digest
[1] = byte_swap_32 (digest
[1]);
14169 digest
[2] = byte_swap_32 (digest
[2]);
14170 digest
[3] = byte_swap_32 (digest
[3]);
14171 digest
[4] = byte_swap_32 (digest
[4]);
14173 digest
[0] -= SHA1M_A
;
14174 digest
[1] -= SHA1M_B
;
14175 digest
[2] -= SHA1M_C
;
14176 digest
[3] -= SHA1M_D
;
14177 digest
[4] -= SHA1M_E
;
14179 return (PARSER_OK
);
14182 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14184 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14186 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14188 salt_t
*salt
= hash_buf
->salt
;
14190 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14191 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14192 digest
[2] = hex_to_uint (&input_buf
[16]);
14193 digest
[3] = hex_to_uint (&input_buf
[24]);
14195 digest
[0] = byte_swap_32 (digest
[0]);
14196 digest
[1] = byte_swap_32 (digest
[1]);
14197 digest
[2] = byte_swap_32 (digest
[2]);
14198 digest
[3] = byte_swap_32 (digest
[3]);
14200 digest
[0] -= MD5M_A
;
14201 digest
[1] -= MD5M_B
;
14202 digest
[2] -= MD5M_C
;
14203 digest
[3] -= MD5M_D
;
14205 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14207 uint salt_len
= input_len
- 32 - 1;
14209 char *salt_buf
= input_buf
+ 32 + 1;
14211 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14213 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14215 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14218 * add static "salt" part
14221 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14225 salt
->salt_len
= salt_len
;
14227 return (PARSER_OK
);
14230 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14232 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14234 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14236 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14238 salt_t
*salt
= hash_buf
->salt
;
14240 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14246 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14248 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14250 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14252 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14254 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14258 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14260 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14262 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14264 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14268 char *keybuf_pos
= strchr (keylen_pos
, '$');
14270 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14272 uint keylen_len
= keybuf_pos
- keylen_pos
;
14274 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14278 char *databuf_pos
= strchr (keybuf_pos
, '$');
14280 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14282 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14284 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14288 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14290 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14296 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14297 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14298 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14299 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14301 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14302 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14303 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14304 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14306 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14307 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14308 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14309 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14311 salt
->salt_len
= 16;
14312 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14314 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14316 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14319 return (PARSER_OK
);
14322 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14324 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14326 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14328 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14330 salt_t
*salt
= hash_buf
->salt
;
14336 // first is the N salt parameter
14338 char *N_pos
= input_buf
+ 6;
14340 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14344 salt
->scrypt_N
= atoi (N_pos
);
14348 char *r_pos
= strchr (N_pos
, ':');
14350 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14354 salt
->scrypt_r
= atoi (r_pos
);
14358 char *p_pos
= strchr (r_pos
, ':');
14360 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14364 salt
->scrypt_p
= atoi (p_pos
);
14368 char *saltbuf_pos
= strchr (p_pos
, ':');
14370 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14374 char *hash_pos
= strchr (saltbuf_pos
, ':');
14376 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14384 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14386 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14388 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14390 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14392 salt
->salt_len
= tmp_len
;
14393 salt
->salt_iter
= 1;
14395 // digest - base64 decode
14397 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14399 tmp_len
= input_len
- (hash_pos
- input_buf
);
14401 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14403 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14405 memcpy (digest
, tmp_buf
, 32);
14407 return (PARSER_OK
);
14410 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14412 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14414 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14416 salt_t
*salt
= hash_buf
->salt
;
14422 char decrypted
[76]; // iv + hash
14424 juniper_decrypt_hash (input_buf
, decrypted
);
14426 char *md5crypt_hash
= decrypted
+ 12;
14428 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14430 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14432 char *salt_pos
= md5crypt_hash
+ 3;
14434 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14436 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14438 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14442 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14444 return (PARSER_OK
);
14447 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14449 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14451 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14453 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14455 salt_t
*salt
= hash_buf
->salt
;
14457 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14463 // first is *raw* salt
14465 char *salt_pos
= input_buf
+ 3;
14467 char *hash_pos
= strchr (salt_pos
, '$');
14469 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14471 uint salt_len
= hash_pos
- salt_pos
;
14473 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14477 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14479 memcpy (salt_buf_ptr
, salt_pos
, 14);
14481 salt_buf_ptr
[17] = 0x01;
14482 salt_buf_ptr
[18] = 0x80;
14484 // add some stuff to normal salt to make sorted happy
14486 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14487 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14488 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14489 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14491 salt
->salt_len
= salt_len
;
14492 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14494 // base64 decode hash
14498 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14500 uint hash_len
= input_len
- 3 - salt_len
- 1;
14502 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14504 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14506 memcpy (digest
, tmp_buf
, 32);
14508 digest
[0] = byte_swap_32 (digest
[0]);
14509 digest
[1] = byte_swap_32 (digest
[1]);
14510 digest
[2] = byte_swap_32 (digest
[2]);
14511 digest
[3] = byte_swap_32 (digest
[3]);
14512 digest
[4] = byte_swap_32 (digest
[4]);
14513 digest
[5] = byte_swap_32 (digest
[5]);
14514 digest
[6] = byte_swap_32 (digest
[6]);
14515 digest
[7] = byte_swap_32 (digest
[7]);
14517 return (PARSER_OK
);
14520 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14522 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14524 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14526 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14528 salt_t
*salt
= hash_buf
->salt
;
14534 // first is *raw* salt
14536 char *salt_pos
= input_buf
+ 3;
14538 char *hash_pos
= strchr (salt_pos
, '$');
14540 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14542 uint salt_len
= hash_pos
- salt_pos
;
14544 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14546 salt
->salt_len
= salt_len
;
14549 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14551 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14552 salt_buf_ptr
[salt_len
] = 0;
14554 // base64 decode hash
14558 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14560 uint hash_len
= input_len
- 3 - salt_len
- 1;
14562 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14564 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14566 memcpy (digest
, tmp_buf
, 32);
14569 salt
->scrypt_N
= 16384;
14570 salt
->scrypt_r
= 1;
14571 salt
->scrypt_p
= 1;
14572 salt
->salt_iter
= 1;
14574 return (PARSER_OK
);
14577 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14579 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14581 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14583 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14585 salt_t
*salt
= hash_buf
->salt
;
14587 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14593 char *version_pos
= input_buf
+ 8 + 1;
14595 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14597 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14599 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14601 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14603 verifierHashSize_pos
++;
14605 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14607 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14609 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14611 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14615 char *saltSize_pos
= strchr (keySize_pos
, '*');
14617 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14619 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14621 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14625 char *osalt_pos
= strchr (saltSize_pos
, '*');
14627 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14629 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14631 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14635 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14637 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14639 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14641 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14643 encryptedVerifier_pos
++;
14645 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14647 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14649 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14651 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14653 encryptedVerifierHash_pos
++;
14655 uint32_t encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - verifierHashSize_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
14657 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14659 const uint version
= atoi (version_pos
);
14661 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14663 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14665 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14667 const uint keySize
= atoi (keySize_pos
);
14669 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14671 office2007
->keySize
= keySize
;
14673 const uint saltSize
= atoi (saltSize_pos
);
14675 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14681 salt
->salt_len
= 16;
14682 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14684 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14685 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14686 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14687 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14693 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14694 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14695 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14696 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14698 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14699 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14700 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14701 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14702 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14708 digest
[0] = office2007
->encryptedVerifierHash
[0];
14709 digest
[1] = office2007
->encryptedVerifierHash
[1];
14710 digest
[2] = office2007
->encryptedVerifierHash
[2];
14711 digest
[3] = office2007
->encryptedVerifierHash
[3];
14713 return (PARSER_OK
);
14716 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14718 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14720 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14722 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14724 salt_t
*salt
= hash_buf
->salt
;
14726 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14732 char *version_pos
= input_buf
+ 8 + 1;
14734 char *spinCount_pos
= strchr (version_pos
, '*');
14736 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14738 uint32_t version_len
= spinCount_pos
- version_pos
;
14740 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14744 char *keySize_pos
= strchr (spinCount_pos
, '*');
14746 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14748 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14750 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14754 char *saltSize_pos
= strchr (keySize_pos
, '*');
14756 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14758 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14760 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14764 char *osalt_pos
= strchr (saltSize_pos
, '*');
14766 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14768 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14770 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14774 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14776 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14778 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14780 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14782 encryptedVerifier_pos
++;
14784 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14786 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14788 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14790 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14792 encryptedVerifierHash_pos
++;
14794 uint32_t encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
14796 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14798 const uint version
= atoi (version_pos
);
14800 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14802 const uint spinCount
= atoi (spinCount_pos
);
14804 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14806 const uint keySize
= atoi (keySize_pos
);
14808 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14810 const uint saltSize
= atoi (saltSize_pos
);
14812 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14818 salt
->salt_len
= 16;
14819 salt
->salt_iter
= spinCount
;
14821 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14822 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14823 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14824 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14830 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14831 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14832 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14833 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14835 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14836 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14837 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14838 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14839 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14840 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14841 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14842 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14848 digest
[0] = office2010
->encryptedVerifierHash
[0];
14849 digest
[1] = office2010
->encryptedVerifierHash
[1];
14850 digest
[2] = office2010
->encryptedVerifierHash
[2];
14851 digest
[3] = office2010
->encryptedVerifierHash
[3];
14853 return (PARSER_OK
);
14856 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14858 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14860 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14862 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14864 salt_t
*salt
= hash_buf
->salt
;
14866 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14872 char *version_pos
= input_buf
+ 8 + 1;
14874 char *spinCount_pos
= strchr (version_pos
, '*');
14876 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14878 uint32_t version_len
= spinCount_pos
- version_pos
;
14880 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14884 char *keySize_pos
= strchr (spinCount_pos
, '*');
14886 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14888 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14890 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14894 char *saltSize_pos
= strchr (keySize_pos
, '*');
14896 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14898 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14900 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14904 char *osalt_pos
= strchr (saltSize_pos
, '*');
14906 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14908 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14910 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14914 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14916 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14918 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14920 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14922 encryptedVerifier_pos
++;
14924 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14926 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14928 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14930 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14932 encryptedVerifierHash_pos
++;
14934 uint32_t encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
14936 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14938 const uint version
= atoi (version_pos
);
14940 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14942 const uint spinCount
= atoi (spinCount_pos
);
14944 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14946 const uint keySize
= atoi (keySize_pos
);
14948 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
14950 const uint saltSize
= atoi (saltSize_pos
);
14952 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14958 salt
->salt_len
= 16;
14959 salt
->salt_iter
= spinCount
;
14961 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14962 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14963 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14964 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14970 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14971 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14972 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14973 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14975 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14976 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14977 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14978 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14979 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14980 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14981 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14982 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14988 digest
[0] = office2013
->encryptedVerifierHash
[0];
14989 digest
[1] = office2013
->encryptedVerifierHash
[1];
14990 digest
[2] = office2013
->encryptedVerifierHash
[2];
14991 digest
[3] = office2013
->encryptedVerifierHash
[3];
14993 return (PARSER_OK
);
14996 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14998 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15000 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15002 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15004 salt_t
*salt
= hash_buf
->salt
;
15006 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15012 char *version_pos
= input_buf
+ 11;
15014 char *osalt_pos
= strchr (version_pos
, '*');
15016 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15018 uint32_t version_len
= osalt_pos
- version_pos
;
15020 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15024 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15026 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15028 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15030 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15032 encryptedVerifier_pos
++;
15034 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15036 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15038 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15040 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15042 encryptedVerifierHash_pos
++;
15044 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15046 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15048 const uint version
= *version_pos
- 0x30;
15050 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15056 oldoffice01
->version
= version
;
15058 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15059 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15060 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15061 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15063 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15064 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15065 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15066 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15068 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15069 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15070 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15071 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15073 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15074 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15075 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15076 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15082 salt
->salt_len
= 16;
15084 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15085 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15086 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15087 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15089 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15090 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15091 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15092 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15094 // this is a workaround as office produces multiple documents with the same salt
15096 salt
->salt_len
+= 32;
15098 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15099 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15100 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15101 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15102 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15103 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15104 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15105 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15111 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15112 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15113 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15114 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15116 return (PARSER_OK
);
15119 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15121 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15124 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15126 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15128 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15130 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15132 salt_t
*salt
= hash_buf
->salt
;
15134 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15140 char *version_pos
= input_buf
+ 11;
15142 char *osalt_pos
= strchr (version_pos
, '*');
15144 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15146 uint32_t version_len
= osalt_pos
- version_pos
;
15148 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15152 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15154 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15156 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15158 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15160 encryptedVerifier_pos
++;
15162 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15164 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15166 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15168 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15170 encryptedVerifierHash_pos
++;
15172 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15174 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15176 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15178 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15182 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15184 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15186 const uint version
= *version_pos
- 0x30;
15188 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15194 oldoffice01
->version
= version
;
15196 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15197 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15198 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15199 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15201 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15202 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15203 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15204 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15206 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15207 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15208 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15209 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15211 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15212 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15213 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15214 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15216 oldoffice01
->rc4key
[1] = 0;
15217 oldoffice01
->rc4key
[0] = 0;
15219 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15220 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15221 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15222 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15223 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15224 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15225 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15226 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15227 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15228 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15230 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15231 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15237 salt
->salt_len
= 16;
15239 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15240 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15241 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15242 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15244 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15245 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15246 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15247 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15249 // this is a workaround as office produces multiple documents with the same salt
15251 salt
->salt_len
+= 32;
15253 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15254 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15255 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15256 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15257 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15258 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15259 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15260 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15266 digest
[0] = oldoffice01
->rc4key
[0];
15267 digest
[1] = oldoffice01
->rc4key
[1];
15271 return (PARSER_OK
);
15274 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15276 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15278 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15280 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15282 salt_t
*salt
= hash_buf
->salt
;
15284 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15290 char *version_pos
= input_buf
+ 11;
15292 char *osalt_pos
= strchr (version_pos
, '*');
15294 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15296 uint32_t version_len
= osalt_pos
- version_pos
;
15298 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15302 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15304 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15306 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15308 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15310 encryptedVerifier_pos
++;
15312 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15314 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15316 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15318 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15320 encryptedVerifierHash_pos
++;
15322 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15324 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15326 const uint version
= *version_pos
- 0x30;
15328 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15334 oldoffice34
->version
= version
;
15336 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15337 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15338 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15339 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15341 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15342 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15343 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15344 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15346 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15347 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15348 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15349 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15350 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15352 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15353 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15354 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15355 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15356 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15362 salt
->salt_len
= 16;
15364 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15365 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15366 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15367 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15369 // this is a workaround as office produces multiple documents with the same salt
15371 salt
->salt_len
+= 32;
15373 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15374 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15375 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15376 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15377 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15378 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15379 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15380 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15386 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15387 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15388 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15389 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15391 return (PARSER_OK
);
15394 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15396 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15398 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15401 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15403 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15405 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15407 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15409 salt_t
*salt
= hash_buf
->salt
;
15411 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15417 char *version_pos
= input_buf
+ 11;
15419 char *osalt_pos
= strchr (version_pos
, '*');
15421 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15423 uint32_t version_len
= osalt_pos
- version_pos
;
15425 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15429 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15431 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15433 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15435 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15437 encryptedVerifier_pos
++;
15439 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15441 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15443 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15445 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15447 encryptedVerifierHash_pos
++;
15449 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15451 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15453 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15455 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15459 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15461 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15463 const uint version
= *version_pos
- 0x30;
15465 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15471 oldoffice34
->version
= version
;
15473 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15474 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15475 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15476 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15478 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15479 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15480 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15481 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15483 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15484 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15485 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15486 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15487 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15489 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15490 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15491 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15492 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15493 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15495 oldoffice34
->rc4key
[1] = 0;
15496 oldoffice34
->rc4key
[0] = 0;
15498 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15499 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15500 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15501 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15502 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15503 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15504 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15505 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15506 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15507 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15509 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15510 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15516 salt
->salt_len
= 16;
15518 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15519 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15520 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15521 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15523 // this is a workaround as office produces multiple documents with the same salt
15525 salt
->salt_len
+= 32;
15527 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15528 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15529 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15530 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15531 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15532 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15533 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15534 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15540 digest
[0] = oldoffice34
->rc4key
[0];
15541 digest
[1] = oldoffice34
->rc4key
[1];
15545 return (PARSER_OK
);
15548 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15550 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15552 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15554 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15555 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15556 digest
[2] = hex_to_uint (&input_buf
[16]);
15557 digest
[3] = hex_to_uint (&input_buf
[24]);
15559 digest
[0] = byte_swap_32 (digest
[0]);
15560 digest
[1] = byte_swap_32 (digest
[1]);
15561 digest
[2] = byte_swap_32 (digest
[2]);
15562 digest
[3] = byte_swap_32 (digest
[3]);
15564 return (PARSER_OK
);
15567 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15569 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15571 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15573 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15575 salt_t
*salt
= hash_buf
->salt
;
15577 char *signature_pos
= input_buf
;
15579 char *salt_pos
= strchr (signature_pos
, '$');
15581 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15583 uint32_t signature_len
= salt_pos
- signature_pos
;
15585 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15589 char *hash_pos
= strchr (salt_pos
, '$');
15591 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15593 uint32_t salt_len
= hash_pos
- salt_pos
;
15595 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15599 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15601 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15603 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15604 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15605 digest
[2] = hex_to_uint (&hash_pos
[16]);
15606 digest
[3] = hex_to_uint (&hash_pos
[24]);
15607 digest
[4] = hex_to_uint (&hash_pos
[32]);
15609 digest
[0] -= SHA1M_A
;
15610 digest
[1] -= SHA1M_B
;
15611 digest
[2] -= SHA1M_C
;
15612 digest
[3] -= SHA1M_D
;
15613 digest
[4] -= SHA1M_E
;
15615 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15617 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15619 salt
->salt_len
= salt_len
;
15621 return (PARSER_OK
);
15624 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15626 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15628 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15630 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15632 salt_t
*salt
= hash_buf
->salt
;
15634 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15640 char *iter_pos
= input_buf
+ 14;
15642 const int iter
= atoi (iter_pos
);
15644 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15646 salt
->salt_iter
= iter
- 1;
15648 char *salt_pos
= strchr (iter_pos
, '$');
15650 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15654 char *hash_pos
= strchr (salt_pos
, '$');
15656 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15658 const uint salt_len
= hash_pos
- salt_pos
;
15662 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15664 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15666 salt
->salt_len
= salt_len
;
15668 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15669 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15671 // add some stuff to normal salt to make sorted happy
15673 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15674 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15675 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15676 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15677 salt
->salt_buf
[4] = salt
->salt_iter
;
15679 // base64 decode hash
15683 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15685 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15687 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15689 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15691 memcpy (digest
, tmp_buf
, 32);
15693 digest
[0] = byte_swap_32 (digest
[0]);
15694 digest
[1] = byte_swap_32 (digest
[1]);
15695 digest
[2] = byte_swap_32 (digest
[2]);
15696 digest
[3] = byte_swap_32 (digest
[3]);
15697 digest
[4] = byte_swap_32 (digest
[4]);
15698 digest
[5] = byte_swap_32 (digest
[5]);
15699 digest
[6] = byte_swap_32 (digest
[6]);
15700 digest
[7] = byte_swap_32 (digest
[7]);
15702 return (PARSER_OK
);
15705 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15707 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15709 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15711 salt_t
*salt
= hash_buf
->salt
;
15713 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15714 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15718 digest
[0] = byte_swap_32 (digest
[0]);
15719 digest
[1] = byte_swap_32 (digest
[1]);
15721 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15722 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15723 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15725 char iter_c
= input_buf
[17];
15726 char iter_d
= input_buf
[19];
15728 // atm only defaults, let's see if there's more request
15729 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15730 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15732 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15734 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15735 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15736 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15737 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15739 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15740 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15741 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15742 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15744 salt
->salt_len
= 16;
15746 return (PARSER_OK
);
15749 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15751 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15753 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15755 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15757 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15759 salt_t
*salt
= hash_buf
->salt
;
15761 char *salt_pos
= input_buf
+ 10;
15763 char *hash_pos
= strchr (salt_pos
, '$');
15765 uint salt_len
= hash_pos
- salt_pos
;
15767 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15771 uint hash_len
= input_len
- 10 - salt_len
- 1;
15773 // base64 decode salt
15777 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15779 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15781 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15783 tmp_buf
[salt_len
] = 0x80;
15785 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15787 salt
->salt_len
= salt_len
;
15789 // base64 decode salt
15791 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15793 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15795 uint user_len
= hash_len
- 32;
15797 char *tmp_hash
= tmp_buf
+ user_len
;
15799 user_len
--; // skip the trailing space
15801 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15802 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15803 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15804 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15806 digest
[0] = byte_swap_32 (digest
[0]);
15807 digest
[1] = byte_swap_32 (digest
[1]);
15808 digest
[2] = byte_swap_32 (digest
[2]);
15809 digest
[3] = byte_swap_32 (digest
[3]);
15811 // store username for host only (output hash if cracked)
15813 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15814 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15816 return (PARSER_OK
);
15819 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15821 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15823 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15825 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15827 salt_t
*salt
= hash_buf
->salt
;
15829 char *iter_pos
= input_buf
+ 10;
15831 uint32_t iter
= atoi (iter_pos
);
15835 return (PARSER_SALT_ITERATION
);
15838 iter
--; // first iteration is special
15840 salt
->salt_iter
= iter
;
15842 char *base64_pos
= strchr (iter_pos
, '}');
15844 if (base64_pos
== NULL
)
15846 return (PARSER_SIGNATURE_UNMATCHED
);
15851 // base64 decode salt
15853 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15857 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15859 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15861 if (decoded_len
< 24)
15863 return (PARSER_SALT_LENGTH
);
15868 uint salt_len
= decoded_len
- 20;
15870 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15871 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15873 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15875 salt
->salt_len
= salt_len
;
15879 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15881 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15882 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15883 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15884 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15885 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15887 return (PARSER_OK
);
15890 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15892 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15894 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15896 salt_t
*salt
= hash_buf
->salt
;
15898 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15899 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15900 digest
[2] = hex_to_uint (&input_buf
[16]);
15901 digest
[3] = hex_to_uint (&input_buf
[24]);
15902 digest
[4] = hex_to_uint (&input_buf
[32]);
15904 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15906 uint salt_len
= input_len
- 40 - 1;
15908 char *salt_buf
= input_buf
+ 40 + 1;
15910 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15912 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15914 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15916 salt
->salt_len
= salt_len
;
15918 return (PARSER_OK
);
15921 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15923 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15925 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15927 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15929 salt_t
*salt
= hash_buf
->salt
;
15931 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15937 char *V_pos
= input_buf
+ 5;
15939 char *R_pos
= strchr (V_pos
, '*');
15941 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15943 uint32_t V_len
= R_pos
- V_pos
;
15947 char *bits_pos
= strchr (R_pos
, '*');
15949 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15951 uint32_t R_len
= bits_pos
- R_pos
;
15955 char *P_pos
= strchr (bits_pos
, '*');
15957 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15959 uint32_t bits_len
= P_pos
- bits_pos
;
15963 char *enc_md_pos
= strchr (P_pos
, '*');
15965 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15967 uint32_t P_len
= enc_md_pos
- P_pos
;
15971 char *id_len_pos
= strchr (enc_md_pos
, '*');
15973 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15975 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
15979 char *id_buf_pos
= strchr (id_len_pos
, '*');
15981 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15983 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
15987 char *u_len_pos
= strchr (id_buf_pos
, '*');
15989 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15991 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
15993 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
15997 char *u_buf_pos
= strchr (u_len_pos
, '*');
15999 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16001 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16005 char *o_len_pos
= strchr (u_buf_pos
, '*');
16007 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16009 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16011 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16015 char *o_buf_pos
= strchr (o_len_pos
, '*');
16017 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16019 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16023 uint32_t 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;
16025 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16029 const int V
= atoi (V_pos
);
16030 const int R
= atoi (R_pos
);
16031 const int P
= atoi (P_pos
);
16033 if (V
!= 1) return (PARSER_SALT_VALUE
);
16034 if (R
!= 2) return (PARSER_SALT_VALUE
);
16036 const int enc_md
= atoi (enc_md_pos
);
16038 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16040 const int id_len
= atoi (id_len_pos
);
16041 const int u_len
= atoi (u_len_pos
);
16042 const int o_len
= atoi (o_len_pos
);
16044 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16045 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16046 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16048 const int bits
= atoi (bits_pos
);
16050 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16052 // copy data to esalt
16058 pdf
->enc_md
= enc_md
;
16060 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16061 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16062 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16063 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16064 pdf
->id_len
= id_len
;
16066 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16067 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16068 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16069 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16070 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16071 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16072 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16073 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16074 pdf
->u_len
= u_len
;
16076 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16077 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16078 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16079 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16080 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16081 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16082 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16083 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16084 pdf
->o_len
= o_len
;
16086 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16087 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16088 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16089 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16091 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16092 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16093 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16094 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16095 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16096 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16097 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16098 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16100 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16101 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16102 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16103 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16104 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16105 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16106 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16107 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16109 // we use ID for salt, maybe needs to change, we will see...
16111 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16112 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16113 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16114 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16115 salt
->salt_len
= pdf
->id_len
;
16117 digest
[0] = pdf
->u_buf
[0];
16118 digest
[1] = pdf
->u_buf
[1];
16119 digest
[2] = pdf
->u_buf
[2];
16120 digest
[3] = pdf
->u_buf
[3];
16122 return (PARSER_OK
);
16125 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16127 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16130 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16132 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16134 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16136 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16138 salt_t
*salt
= hash_buf
->salt
;
16140 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16146 char *V_pos
= input_buf
+ 5;
16148 char *R_pos
= strchr (V_pos
, '*');
16150 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16152 uint32_t V_len
= R_pos
- V_pos
;
16156 char *bits_pos
= strchr (R_pos
, '*');
16158 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16160 uint32_t R_len
= bits_pos
- R_pos
;
16164 char *P_pos
= strchr (bits_pos
, '*');
16166 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16168 uint32_t bits_len
= P_pos
- bits_pos
;
16172 char *enc_md_pos
= strchr (P_pos
, '*');
16174 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16176 uint32_t P_len
= enc_md_pos
- P_pos
;
16180 char *id_len_pos
= strchr (enc_md_pos
, '*');
16182 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16184 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16188 char *id_buf_pos
= strchr (id_len_pos
, '*');
16190 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16192 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16196 char *u_len_pos
= strchr (id_buf_pos
, '*');
16198 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16200 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16202 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16206 char *u_buf_pos
= strchr (u_len_pos
, '*');
16208 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16210 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16214 char *o_len_pos
= strchr (u_buf_pos
, '*');
16216 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16218 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16220 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16224 char *o_buf_pos
= strchr (o_len_pos
, '*');
16226 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16228 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16232 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16234 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16236 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16238 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16242 uint32_t 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;
16244 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16248 const int V
= atoi (V_pos
);
16249 const int R
= atoi (R_pos
);
16250 const int P
= atoi (P_pos
);
16252 if (V
!= 1) return (PARSER_SALT_VALUE
);
16253 if (R
!= 2) return (PARSER_SALT_VALUE
);
16255 const int enc_md
= atoi (enc_md_pos
);
16257 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16259 const int id_len
= atoi (id_len_pos
);
16260 const int u_len
= atoi (u_len_pos
);
16261 const int o_len
= atoi (o_len_pos
);
16263 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16264 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16265 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16267 const int bits
= atoi (bits_pos
);
16269 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16271 // copy data to esalt
16277 pdf
->enc_md
= enc_md
;
16279 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16280 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16281 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16282 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16283 pdf
->id_len
= id_len
;
16285 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16286 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16287 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16288 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16289 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16290 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16291 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16292 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16293 pdf
->u_len
= u_len
;
16295 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16296 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16297 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16298 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16299 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16300 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16301 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16302 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16303 pdf
->o_len
= o_len
;
16305 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16306 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16307 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16308 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16310 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16311 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16312 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16313 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16314 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16315 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16316 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16317 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16319 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16320 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16321 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16322 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16323 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16324 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16325 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16326 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16328 pdf
->rc4key
[1] = 0;
16329 pdf
->rc4key
[0] = 0;
16331 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16332 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16333 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16334 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16335 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16336 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16337 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16338 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16339 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16340 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16342 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16343 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16345 // we use ID for salt, maybe needs to change, we will see...
16347 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16348 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16349 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16350 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16351 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16352 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16353 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16354 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16355 salt
->salt_len
= pdf
->id_len
+ 16;
16357 digest
[0] = pdf
->rc4key
[0];
16358 digest
[1] = pdf
->rc4key
[1];
16362 return (PARSER_OK
);
16365 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16367 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16369 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16371 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16373 salt_t
*salt
= hash_buf
->salt
;
16375 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16381 char *V_pos
= input_buf
+ 5;
16383 char *R_pos
= strchr (V_pos
, '*');
16385 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16387 uint32_t V_len
= R_pos
- V_pos
;
16391 char *bits_pos
= strchr (R_pos
, '*');
16393 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16395 uint32_t R_len
= bits_pos
- R_pos
;
16399 char *P_pos
= strchr (bits_pos
, '*');
16401 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16403 uint32_t bits_len
= P_pos
- bits_pos
;
16407 char *enc_md_pos
= strchr (P_pos
, '*');
16409 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16411 uint32_t P_len
= enc_md_pos
- P_pos
;
16415 char *id_len_pos
= strchr (enc_md_pos
, '*');
16417 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16419 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16423 char *id_buf_pos
= strchr (id_len_pos
, '*');
16425 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16427 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16431 char *u_len_pos
= strchr (id_buf_pos
, '*');
16433 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16435 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16437 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16441 char *u_buf_pos
= strchr (u_len_pos
, '*');
16443 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16445 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16449 char *o_len_pos
= strchr (u_buf_pos
, '*');
16451 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16453 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16455 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16459 char *o_buf_pos
= strchr (o_len_pos
, '*');
16461 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16463 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16467 uint32_t 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;
16469 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16473 const int V
= atoi (V_pos
);
16474 const int R
= atoi (R_pos
);
16475 const int P
= atoi (P_pos
);
16479 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16480 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16482 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16484 const int id_len
= atoi (id_len_pos
);
16485 const int u_len
= atoi (u_len_pos
);
16486 const int o_len
= atoi (o_len_pos
);
16488 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16490 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16491 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16493 const int bits
= atoi (bits_pos
);
16495 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16501 enc_md
= atoi (enc_md_pos
);
16504 // copy data to esalt
16510 pdf
->enc_md
= enc_md
;
16512 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16513 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16514 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16515 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16519 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16520 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16521 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16522 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16525 pdf
->id_len
= id_len
;
16527 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16528 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16529 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16530 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16531 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16532 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16533 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16534 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16535 pdf
->u_len
= u_len
;
16537 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16538 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16539 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16540 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16541 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16542 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16543 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16544 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16545 pdf
->o_len
= o_len
;
16547 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16548 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16549 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16550 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16554 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16555 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16556 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16557 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16560 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16561 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16562 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16563 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16564 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16565 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16566 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16567 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16569 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16570 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16571 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16572 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16573 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16574 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16575 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16576 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16578 // precompute rc4 data for later use
16594 uint salt_pc_block
[32];
16596 char *salt_pc_ptr
= (char *) salt_pc_block
;
16598 memcpy (salt_pc_ptr
, padding
, 32);
16599 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16601 uint salt_pc_digest
[4];
16603 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16605 pdf
->rc4data
[0] = salt_pc_digest
[0];
16606 pdf
->rc4data
[1] = salt_pc_digest
[1];
16608 // we use ID for salt, maybe needs to change, we will see...
16610 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16611 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16612 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16613 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16614 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16615 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16616 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16617 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16618 salt
->salt_len
= pdf
->id_len
+ 16;
16620 salt
->salt_iter
= ROUNDS_PDF14
;
16622 digest
[0] = pdf
->u_buf
[0];
16623 digest
[1] = pdf
->u_buf
[1];
16627 return (PARSER_OK
);
16630 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16632 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16634 if (ret
!= PARSER_OK
)
16639 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16641 salt_t
*salt
= hash_buf
->salt
;
16643 digest
[0] -= SHA256M_A
;
16644 digest
[1] -= SHA256M_B
;
16645 digest
[2] -= SHA256M_C
;
16646 digest
[3] -= SHA256M_D
;
16647 digest
[4] -= SHA256M_E
;
16648 digest
[5] -= SHA256M_F
;
16649 digest
[6] -= SHA256M_G
;
16650 digest
[7] -= SHA256M_H
;
16652 salt
->salt_buf
[2] = 0x80;
16654 return (PARSER_OK
);
16657 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16659 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16661 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16663 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16665 salt_t
*salt
= hash_buf
->salt
;
16667 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16673 char *V_pos
= input_buf
+ 5;
16675 char *R_pos
= strchr (V_pos
, '*');
16677 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16679 uint32_t V_len
= R_pos
- V_pos
;
16683 char *bits_pos
= strchr (R_pos
, '*');
16685 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16687 uint32_t R_len
= bits_pos
- R_pos
;
16691 char *P_pos
= strchr (bits_pos
, '*');
16693 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16695 uint32_t bits_len
= P_pos
- bits_pos
;
16699 char *enc_md_pos
= strchr (P_pos
, '*');
16701 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16703 uint32_t P_len
= enc_md_pos
- P_pos
;
16707 char *id_len_pos
= strchr (enc_md_pos
, '*');
16709 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16711 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16715 char *id_buf_pos
= strchr (id_len_pos
, '*');
16717 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16719 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16723 char *u_len_pos
= strchr (id_buf_pos
, '*');
16725 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16727 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16731 char *u_buf_pos
= strchr (u_len_pos
, '*');
16733 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16735 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16739 char *o_len_pos
= strchr (u_buf_pos
, '*');
16741 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16743 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16747 char *o_buf_pos
= strchr (o_len_pos
, '*');
16749 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16751 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16755 char *last
= strchr (o_buf_pos
, '*');
16757 if (last
== NULL
) last
= input_buf
+ input_len
;
16759 uint32_t o_buf_len
= last
- o_buf_pos
;
16763 const int V
= atoi (V_pos
);
16764 const int R
= atoi (R_pos
);
16768 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16769 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16771 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16773 const int bits
= atoi (bits_pos
);
16775 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16777 int enc_md
= atoi (enc_md_pos
);
16779 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16781 const uint id_len
= atoi (id_len_pos
);
16782 const uint u_len
= atoi (u_len_pos
);
16783 const uint o_len
= atoi (o_len_pos
);
16785 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16786 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16787 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16788 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16789 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16790 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16791 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16792 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16794 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16795 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16796 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16798 // copy data to esalt
16800 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16802 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16804 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16807 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16808 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16810 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16811 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16813 salt
->salt_len
= 8;
16814 salt
->salt_iter
= ROUNDS_PDF17L8
;
16816 digest
[0] = pdf
->u_buf
[0];
16817 digest
[1] = pdf
->u_buf
[1];
16818 digest
[2] = pdf
->u_buf
[2];
16819 digest
[3] = pdf
->u_buf
[3];
16820 digest
[4] = pdf
->u_buf
[4];
16821 digest
[5] = pdf
->u_buf
[5];
16822 digest
[6] = pdf
->u_buf
[6];
16823 digest
[7] = pdf
->u_buf
[7];
16825 return (PARSER_OK
);
16828 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16830 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16832 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16834 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16836 salt_t
*salt
= hash_buf
->salt
;
16838 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16846 char *iter_pos
= input_buf
+ 7;
16848 uint32_t iter
= atoi (iter_pos
);
16850 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16851 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16853 // first is *raw* salt
16855 char *salt_pos
= strchr (iter_pos
, ':');
16857 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16861 char *hash_pos
= strchr (salt_pos
, ':');
16863 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16865 uint32_t salt_len
= hash_pos
- salt_pos
;
16867 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16871 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16873 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16877 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16879 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16881 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16883 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16884 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16886 salt
->salt_len
= salt_len
;
16887 salt
->salt_iter
= iter
- 1;
16893 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16895 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16897 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16899 memcpy (digest
, tmp_buf
, 16);
16901 digest
[0] = byte_swap_32 (digest
[0]);
16902 digest
[1] = byte_swap_32 (digest
[1]);
16903 digest
[2] = byte_swap_32 (digest
[2]);
16904 digest
[3] = byte_swap_32 (digest
[3]);
16906 // add some stuff to normal salt to make sorted happy
16908 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16909 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16910 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16911 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16912 salt
->salt_buf
[4] = salt
->salt_iter
;
16914 return (PARSER_OK
);
16917 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16919 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16921 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16923 salt_t
*salt
= hash_buf
->salt
;
16925 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16926 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16927 digest
[2] = hex_to_uint (&input_buf
[16]);
16928 digest
[3] = hex_to_uint (&input_buf
[24]);
16930 digest
[0] = byte_swap_32 (digest
[0]);
16931 digest
[1] = byte_swap_32 (digest
[1]);
16932 digest
[2] = byte_swap_32 (digest
[2]);
16933 digest
[3] = byte_swap_32 (digest
[3]);
16935 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16937 uint salt_len
= input_len
- 32 - 1;
16939 char *salt_buf
= input_buf
+ 32 + 1;
16941 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16943 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16945 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16947 salt
->salt_len
= salt_len
;
16949 return (PARSER_OK
);
16952 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16954 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
16956 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16958 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16960 salt_t
*salt
= hash_buf
->salt
;
16962 char *user_pos
= input_buf
+ 10;
16964 char *salt_pos
= strchr (user_pos
, '*');
16966 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16970 char *hash_pos
= strchr (salt_pos
, '*');
16974 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16976 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
16978 uint user_len
= salt_pos
- user_pos
- 1;
16980 uint salt_len
= hash_pos
- salt_pos
- 1;
16982 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
16988 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
16989 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
16990 digest
[2] = hex_to_uint (&hash_pos
[16]);
16991 digest
[3] = hex_to_uint (&hash_pos
[24]);
16993 digest
[0] = byte_swap_32 (digest
[0]);
16994 digest
[1] = byte_swap_32 (digest
[1]);
16995 digest
[2] = byte_swap_32 (digest
[2]);
16996 digest
[3] = byte_swap_32 (digest
[3]);
16998 digest
[0] -= MD5M_A
;
16999 digest
[1] -= MD5M_B
;
17000 digest
[2] -= MD5M_C
;
17001 digest
[3] -= MD5M_D
;
17007 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17009 // first 4 bytes are the "challenge"
17011 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17012 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17013 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17014 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17016 // append the user name
17018 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17020 salt
->salt_len
= 4 + user_len
;
17022 return (PARSER_OK
);
17025 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17027 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17029 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17031 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17033 salt_t
*salt
= hash_buf
->salt
;
17035 char *salt_pos
= input_buf
+ 9;
17037 char *hash_pos
= strchr (salt_pos
, '*');
17039 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17043 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17045 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17047 uint salt_len
= hash_pos
- salt_pos
- 1;
17049 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17055 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17056 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17057 digest
[2] = hex_to_uint (&hash_pos
[16]);
17058 digest
[3] = hex_to_uint (&hash_pos
[24]);
17059 digest
[4] = hex_to_uint (&hash_pos
[32]);
17065 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17067 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17069 salt
->salt_len
= salt_len
;
17071 return (PARSER_OK
);
17074 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17076 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17078 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17080 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17082 salt_t
*salt
= hash_buf
->salt
;
17084 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17090 char *cry_master_len_pos
= input_buf
+ 9;
17092 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17094 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17096 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17098 cry_master_buf_pos
++;
17100 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17102 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17104 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17106 cry_salt_len_pos
++;
17108 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17110 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17112 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17114 cry_salt_buf_pos
++;
17116 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17118 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17120 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17124 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17126 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17128 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17132 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17134 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17136 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17140 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17142 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17144 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17146 public_key_len_pos
++;
17148 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17150 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17152 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17154 public_key_buf_pos
++;
17156 uint32_t 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;
17158 const uint cry_master_len
= atoi (cry_master_len_pos
);
17159 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17160 const uint ckey_len
= atoi (ckey_len_pos
);
17161 const uint public_key_len
= atoi (public_key_len_pos
);
17163 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17164 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17165 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17166 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17168 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17170 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17172 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17175 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17177 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17179 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17182 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17184 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17186 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17189 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17190 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17191 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17194 * store digest (should be unique enought, hopefully)
17197 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17198 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17199 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17200 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17206 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17208 const uint cry_rounds
= atoi (cry_rounds_pos
);
17210 salt
->salt_iter
= cry_rounds
- 1;
17212 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17214 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17216 salt
->salt_len
= salt_len
;
17218 return (PARSER_OK
);
17221 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17223 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17225 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17227 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17229 salt_t
*salt
= hash_buf
->salt
;
17231 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17233 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17235 char temp_input_buf
[input_len
+ 1];
17237 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17238 memcpy (temp_input_buf
, input_buf
, input_len
);
17242 char *URI_server_pos
= temp_input_buf
+ 6;
17244 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17246 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17248 URI_client_pos
[0] = 0;
17251 uint URI_server_len
= strlen (URI_server_pos
);
17253 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17257 char *user_pos
= strchr (URI_client_pos
, '*');
17259 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17264 uint URI_client_len
= strlen (URI_client_pos
);
17266 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17270 char *realm_pos
= strchr (user_pos
, '*');
17272 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17277 uint user_len
= strlen (user_pos
);
17279 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17283 char *method_pos
= strchr (realm_pos
, '*');
17285 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17290 uint realm_len
= strlen (realm_pos
);
17292 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17296 char *URI_prefix_pos
= strchr (method_pos
, '*');
17298 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 URI_prefix_pos
[0] = 0;
17303 uint method_len
= strlen (method_pos
);
17305 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17309 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17311 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17313 URI_resource_pos
[0] = 0;
17314 URI_resource_pos
++;
17316 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17318 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17322 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17324 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17326 URI_suffix_pos
[0] = 0;
17329 uint URI_resource_len
= strlen (URI_resource_pos
);
17331 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17332 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17336 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17338 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17343 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17345 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17349 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17351 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17353 nonce_client_pos
[0] = 0;
17354 nonce_client_pos
++;
17356 uint nonce_len
= strlen (nonce_pos
);
17358 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17359 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17363 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17365 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17367 nonce_count_pos
[0] = 0;
17370 uint nonce_client_len
= strlen (nonce_client_pos
);
17372 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17376 char *qop_pos
= strchr (nonce_count_pos
, '*');
17378 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17383 uint nonce_count_len
= strlen (nonce_count_pos
);
17385 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17389 char *directive_pos
= strchr (qop_pos
, '*');
17391 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17393 directive_pos
[0] = 0;
17396 uint qop_len
= strlen (qop_pos
);
17398 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17402 char *digest_pos
= strchr (directive_pos
, '*');
17404 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17409 uint directive_len
= strlen (directive_pos
);
17411 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17413 if (memcmp (directive_pos
, "MD5", 3))
17415 log_info ("ERROR: only the MD5 directive is currently supported\n");
17417 return (PARSER_SIP_AUTH_DIRECTIVE
);
17421 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17426 uint md5_max_len
= 4 * 64;
17428 uint md5_remaining_len
= md5_max_len
;
17430 uint tmp_md5_buf
[md5_max_len
/ 4];
17432 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17434 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17436 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17438 md5_len
+= method_len
+ 1;
17439 tmp_md5_ptr
+= method_len
+ 1;
17441 if (URI_prefix_len
> 0)
17443 md5_remaining_len
= md5_max_len
- md5_len
;
17445 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17447 md5_len
+= URI_prefix_len
+ 1;
17448 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17451 md5_remaining_len
= md5_max_len
- md5_len
;
17453 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17455 md5_len
+= URI_resource_len
;
17456 tmp_md5_ptr
+= URI_resource_len
;
17458 if (URI_suffix_len
> 0)
17460 md5_remaining_len
= md5_max_len
- md5_len
;
17462 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17464 md5_len
+= 1 + URI_suffix_len
;
17467 uint tmp_digest
[4];
17469 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17471 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17472 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17473 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17474 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17480 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17482 uint esalt_len
= 0;
17484 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17486 // there are 2 possibilities for the esalt:
17488 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17490 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17492 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17494 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17506 esalt_len
= 1 + nonce_len
+ 1 + 32;
17508 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17510 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17518 // add 0x80 to esalt
17520 esalt_buf_ptr
[esalt_len
] = 0x80;
17522 sip
->esalt_len
= esalt_len
;
17528 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17530 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17532 uint max_salt_len
= 119;
17534 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17536 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17538 sip
->salt_len
= salt_len
;
17541 * fake salt (for sorting)
17544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17548 uint fake_salt_len
= salt_len
;
17550 if (fake_salt_len
> max_salt_len
)
17552 fake_salt_len
= max_salt_len
;
17555 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17557 salt
->salt_len
= fake_salt_len
;
17563 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17564 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17565 digest
[2] = hex_to_uint (&digest_pos
[16]);
17566 digest
[3] = hex_to_uint (&digest_pos
[24]);
17568 digest
[0] = byte_swap_32 (digest
[0]);
17569 digest
[1] = byte_swap_32 (digest
[1]);
17570 digest
[2] = byte_swap_32 (digest
[2]);
17571 digest
[3] = byte_swap_32 (digest
[3]);
17573 return (PARSER_OK
);
17576 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17578 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17580 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17582 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17584 salt_t
*salt
= hash_buf
->salt
;
17588 char *digest_pos
= input_buf
;
17590 digest
[0] = hex_to_uint (&digest_pos
[0]);
17597 char *salt_buf
= input_buf
+ 8 + 1;
17601 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17603 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17605 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17607 salt
->salt_len
= salt_len
;
17609 return (PARSER_OK
);
17612 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17614 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17616 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17618 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17620 salt_t
*salt
= hash_buf
->salt
;
17622 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17628 char *p_buf_pos
= input_buf
+ 4;
17630 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17632 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17634 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17636 NumCyclesPower_pos
++;
17638 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17640 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17642 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17646 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17648 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17650 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17654 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17656 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17658 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17662 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17664 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17666 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17670 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17672 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17674 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17678 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17680 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17682 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17686 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17688 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17690 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17694 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17696 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17698 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17702 uint32_t 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;
17704 const uint iter
= atoi (NumCyclesPower_pos
);
17705 const uint crc
= atoi (crc_buf_pos
);
17706 const uint p_buf
= atoi (p_buf_pos
);
17707 const uint salt_len
= atoi (salt_len_pos
);
17708 const uint iv_len
= atoi (iv_len_pos
);
17709 const uint unpack_size
= atoi (unpack_size_pos
);
17710 const uint data_len
= atoi (data_len_pos
);
17716 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17717 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17719 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17721 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17723 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17729 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17730 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17731 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17732 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17734 seven_zip
->iv_len
= iv_len
;
17736 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17738 seven_zip
->salt_len
= 0;
17740 seven_zip
->crc
= crc
;
17742 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17744 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17746 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17749 seven_zip
->data_len
= data_len
;
17751 seven_zip
->unpack_size
= unpack_size
;
17755 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17756 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17757 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17758 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17760 salt
->salt_len
= 16;
17762 salt
->salt_sign
[0] = iter
;
17764 salt
->salt_iter
= 1 << iter
;
17775 return (PARSER_OK
);
17778 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17780 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17782 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17784 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17785 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17786 digest
[2] = hex_to_uint (&input_buf
[16]);
17787 digest
[3] = hex_to_uint (&input_buf
[24]);
17788 digest
[4] = hex_to_uint (&input_buf
[32]);
17789 digest
[5] = hex_to_uint (&input_buf
[40]);
17790 digest
[6] = hex_to_uint (&input_buf
[48]);
17791 digest
[7] = hex_to_uint (&input_buf
[56]);
17793 digest
[0] = byte_swap_32 (digest
[0]);
17794 digest
[1] = byte_swap_32 (digest
[1]);
17795 digest
[2] = byte_swap_32 (digest
[2]);
17796 digest
[3] = byte_swap_32 (digest
[3]);
17797 digest
[4] = byte_swap_32 (digest
[4]);
17798 digest
[5] = byte_swap_32 (digest
[5]);
17799 digest
[6] = byte_swap_32 (digest
[6]);
17800 digest
[7] = byte_swap_32 (digest
[7]);
17802 return (PARSER_OK
);
17805 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17807 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17809 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17811 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17812 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17813 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17814 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17815 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17816 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17817 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17818 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17819 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17820 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17821 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17822 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17823 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17824 digest
[13] = hex_to_uint (&input_buf
[104]);
17825 digest
[14] = hex_to_uint (&input_buf
[112]);
17826 digest
[15] = hex_to_uint (&input_buf
[120]);
17828 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17829 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17830 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17831 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17832 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17833 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17834 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17835 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17836 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17837 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17838 digest
[10] = byte_swap_32 (digest
[10]);
17839 digest
[11] = byte_swap_32 (digest
[11]);
17840 digest
[12] = byte_swap_32 (digest
[12]);
17841 digest
[13] = byte_swap_32 (digest
[13]);
17842 digest
[14] = byte_swap_32 (digest
[14]);
17843 digest
[15] = byte_swap_32 (digest
[15]);
17845 return (PARSER_OK
);
17848 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17850 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17852 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17854 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17856 salt_t
*salt
= hash_buf
->salt
;
17858 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17866 char *iter_pos
= input_buf
+ 4;
17868 uint32_t iter
= atoi (iter_pos
);
17870 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17871 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17873 // first is *raw* salt
17875 char *salt_pos
= strchr (iter_pos
, ':');
17877 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17881 char *hash_pos
= strchr (salt_pos
, ':');
17883 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17885 uint32_t salt_len
= hash_pos
- salt_pos
;
17887 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17891 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17893 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17897 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17899 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17901 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17903 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17904 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17906 salt
->salt_len
= salt_len
;
17907 salt
->salt_iter
= iter
- 1;
17913 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17915 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17917 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17919 memcpy (digest
, tmp_buf
, 16);
17921 // add some stuff to normal salt to make sorted happy
17923 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17924 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17925 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17926 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17927 salt
->salt_buf
[4] = salt
->salt_iter
;
17929 return (PARSER_OK
);
17932 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17934 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17936 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17938 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17940 salt_t
*salt
= hash_buf
->salt
;
17942 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
17950 char *iter_pos
= input_buf
+ 5;
17952 uint32_t iter
= atoi (iter_pos
);
17954 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17955 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17957 // first is *raw* salt
17959 char *salt_pos
= strchr (iter_pos
, ':');
17961 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17965 char *hash_pos
= strchr (salt_pos
, ':');
17967 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17969 uint32_t salt_len
= hash_pos
- salt_pos
;
17971 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17975 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17977 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17981 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
17983 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17985 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17987 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17988 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17990 salt
->salt_len
= salt_len
;
17991 salt
->salt_iter
= iter
- 1;
17997 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17999 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18001 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18003 memcpy (digest
, tmp_buf
, 16);
18005 digest
[0] = byte_swap_32 (digest
[0]);
18006 digest
[1] = byte_swap_32 (digest
[1]);
18007 digest
[2] = byte_swap_32 (digest
[2]);
18008 digest
[3] = byte_swap_32 (digest
[3]);
18010 // add some stuff to normal salt to make sorted happy
18012 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18013 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18014 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18015 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18016 salt
->salt_buf
[4] = salt
->salt_iter
;
18018 return (PARSER_OK
);
18021 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18023 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18025 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18027 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18029 salt_t
*salt
= hash_buf
->salt
;
18031 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18039 char *iter_pos
= input_buf
+ 7;
18041 uint32_t iter
= atoi (iter_pos
);
18043 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18044 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18046 // first is *raw* salt
18048 char *salt_pos
= strchr (iter_pos
, ':');
18050 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18054 char *hash_pos
= strchr (salt_pos
, ':');
18056 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18058 uint32_t salt_len
= hash_pos
- salt_pos
;
18060 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18064 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18066 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18070 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18072 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18074 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18076 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18077 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18079 salt
->salt_len
= salt_len
;
18080 salt
->salt_iter
= iter
- 1;
18086 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18088 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18090 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18092 memcpy (digest
, tmp_buf
, 64);
18094 digest
[0] = byte_swap_64 (digest
[0]);
18095 digest
[1] = byte_swap_64 (digest
[1]);
18096 digest
[2] = byte_swap_64 (digest
[2]);
18097 digest
[3] = byte_swap_64 (digest
[3]);
18098 digest
[4] = byte_swap_64 (digest
[4]);
18099 digest
[5] = byte_swap_64 (digest
[5]);
18100 digest
[6] = byte_swap_64 (digest
[6]);
18101 digest
[7] = byte_swap_64 (digest
[7]);
18103 // add some stuff to normal salt to make sorted happy
18105 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18106 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18107 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18108 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18109 salt
->salt_buf
[4] = salt
->salt_iter
;
18111 return (PARSER_OK
);
18114 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18116 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18118 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18120 uint
*digest
= (uint
*) hash_buf
->digest
;
18122 salt_t
*salt
= hash_buf
->salt
;
18128 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18130 char *hash_pos
= strchr (salt_pos
, '$');
18132 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18134 uint32_t salt_len
= hash_pos
- salt_pos
;
18136 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18140 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18142 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18146 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18147 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18165 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18166 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18168 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18169 salt
->salt_len
= 8;
18171 return (PARSER_OK
);
18174 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18176 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18178 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18180 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18182 if (c19
& 3) return (PARSER_HASH_VALUE
);
18184 salt_t
*salt
= hash_buf
->salt
;
18186 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18190 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18191 | itoa64_to_int (input_buf
[2]) << 6
18192 | itoa64_to_int (input_buf
[3]) << 12
18193 | itoa64_to_int (input_buf
[4]) << 18;
18197 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18198 | itoa64_to_int (input_buf
[6]) << 6
18199 | itoa64_to_int (input_buf
[7]) << 12
18200 | itoa64_to_int (input_buf
[8]) << 18;
18202 salt
->salt_len
= 4;
18206 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18208 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18210 memcpy (digest
, tmp_buf
, 8);
18214 IP (digest
[0], digest
[1], tt
);
18216 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18217 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18221 return (PARSER_OK
);
18224 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18226 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18228 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18230 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18232 salt_t
*salt
= hash_buf
->salt
;
18238 char *type_pos
= input_buf
+ 6 + 1;
18240 char *salt_pos
= strchr (type_pos
, '*');
18242 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18244 uint32_t type_len
= salt_pos
- type_pos
;
18246 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18250 char *crypted_pos
= strchr (salt_pos
, '*');
18252 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18254 uint32_t salt_len
= crypted_pos
- salt_pos
;
18256 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18260 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18262 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18268 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18269 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18271 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18272 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18274 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18275 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18276 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18277 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18279 salt
->salt_len
= 24;
18280 salt
->salt_iter
= ROUNDS_RAR3
;
18282 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18283 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18285 digest
[0] = 0xc43d7b00;
18286 digest
[1] = 0x40070000;
18290 return (PARSER_OK
);
18293 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18295 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18297 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18299 salt_t
*salt
= hash_buf
->salt
;
18301 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18302 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18303 digest
[2] = hex_to_uint (&input_buf
[16]);
18304 digest
[3] = hex_to_uint (&input_buf
[24]);
18305 digest
[4] = hex_to_uint (&input_buf
[32]);
18306 digest
[5] = hex_to_uint (&input_buf
[40]);
18307 digest
[6] = hex_to_uint (&input_buf
[48]);
18308 digest
[7] = hex_to_uint (&input_buf
[56]);
18310 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18312 uint salt_len
= input_len
- 64 - 1;
18314 char *salt_buf
= input_buf
+ 64 + 1;
18316 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18318 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18320 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18322 salt
->salt_len
= salt_len
;
18325 * we can precompute the first sha256 transform
18330 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18331 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18332 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18333 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18334 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18335 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18336 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18337 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18338 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18339 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18340 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18341 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18342 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18343 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18344 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18345 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18349 pc256
[0] = SHA256M_A
;
18350 pc256
[1] = SHA256M_B
;
18351 pc256
[2] = SHA256M_C
;
18352 pc256
[3] = SHA256M_D
;
18353 pc256
[4] = SHA256M_E
;
18354 pc256
[5] = SHA256M_F
;
18355 pc256
[6] = SHA256M_G
;
18356 pc256
[7] = SHA256M_H
;
18358 sha256_64 (w
, pc256
);
18360 salt
->salt_buf_pc
[0] = pc256
[0];
18361 salt
->salt_buf_pc
[1] = pc256
[1];
18362 salt
->salt_buf_pc
[2] = pc256
[2];
18363 salt
->salt_buf_pc
[3] = pc256
[3];
18364 salt
->salt_buf_pc
[4] = pc256
[4];
18365 salt
->salt_buf_pc
[5] = pc256
[5];
18366 salt
->salt_buf_pc
[6] = pc256
[6];
18367 salt
->salt_buf_pc
[7] = pc256
[7];
18369 digest
[0] -= pc256
[0];
18370 digest
[1] -= pc256
[1];
18371 digest
[2] -= pc256
[2];
18372 digest
[3] -= pc256
[3];
18373 digest
[4] -= pc256
[4];
18374 digest
[5] -= pc256
[5];
18375 digest
[6] -= pc256
[6];
18376 digest
[7] -= pc256
[7];
18378 return (PARSER_OK
);
18381 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18383 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18385 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18387 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18389 salt_t
*salt
= hash_buf
->salt
;
18395 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18397 char *data_buf_pos
= strchr (data_len_pos
, '$');
18399 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18401 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18403 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18404 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18408 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18410 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18412 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18414 uint32_t data_len
= atoi (data_len_pos
);
18416 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18422 char *salt_pos
= data_buf_pos
;
18424 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18425 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18426 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18427 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18429 // this is actually the CT, which is also the hash later (if matched)
18431 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18432 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18433 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18434 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18436 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18438 salt
->salt_iter
= 10 - 1;
18444 digest
[0] = salt
->salt_buf
[4];
18445 digest
[1] = salt
->salt_buf
[5];
18446 digest
[2] = salt
->salt_buf
[6];
18447 digest
[3] = salt
->salt_buf
[7];
18449 return (PARSER_OK
);
18452 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18454 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18456 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18458 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18460 salt_t
*salt
= hash_buf
->salt
;
18466 char *salt_pos
= input_buf
+ 11 + 1;
18468 char *iter_pos
= strchr (salt_pos
, ',');
18470 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18472 uint32_t salt_len
= iter_pos
- salt_pos
;
18474 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18478 char *hash_pos
= strchr (iter_pos
, ',');
18480 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18482 uint32_t iter_len
= hash_pos
- iter_pos
;
18484 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18488 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18490 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18496 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18497 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18498 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18499 salt
->salt_buf
[3] = 0x00018000;
18501 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18502 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18503 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18504 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18506 salt
->salt_len
= salt_len
/ 2;
18508 salt
->salt_iter
= atoi (iter_pos
) - 1;
18514 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18515 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18516 digest
[2] = hex_to_uint (&hash_pos
[16]);
18517 digest
[3] = hex_to_uint (&hash_pos
[24]);
18518 digest
[4] = hex_to_uint (&hash_pos
[32]);
18519 digest
[5] = hex_to_uint (&hash_pos
[40]);
18520 digest
[6] = hex_to_uint (&hash_pos
[48]);
18521 digest
[7] = hex_to_uint (&hash_pos
[56]);
18523 return (PARSER_OK
);
18527 * parallel running threads
18532 BOOL WINAPI
sigHandler_default (DWORD sig
)
18536 case CTRL_CLOSE_EVENT
:
18539 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18540 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18541 * function otherwise it is to late (e.g. after returning from this function)
18546 SetConsoleCtrlHandler (NULL
, TRUE
);
18553 case CTRL_LOGOFF_EVENT
:
18554 case CTRL_SHUTDOWN_EVENT
:
18558 SetConsoleCtrlHandler (NULL
, TRUE
);
18566 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18570 case CTRL_CLOSE_EVENT
:
18574 SetConsoleCtrlHandler (NULL
, TRUE
);
18581 case CTRL_LOGOFF_EVENT
:
18582 case CTRL_SHUTDOWN_EVENT
:
18586 SetConsoleCtrlHandler (NULL
, TRUE
);
18594 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18596 if (callback
== NULL
)
18598 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18602 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18608 void sigHandler_default (int sig
)
18612 signal (sig
, NULL
);
18615 void sigHandler_benchmark (int sig
)
18619 signal (sig
, NULL
);
18622 void hc_signal (void (callback
) (int))
18624 if (callback
== NULL
) callback
= SIG_DFL
;
18626 signal (SIGINT
, callback
);
18627 signal (SIGTERM
, callback
);
18628 signal (SIGABRT
, callback
);
18633 void status_display ();
18635 void *thread_keypress (void *p
)
18637 int benchmark
= *((int *) p
);
18639 uint quiet
= data
.quiet
;
18643 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18645 int ch
= tty_getchar();
18647 if (ch
== -1) break;
18649 if (ch
== 0) continue;
18655 hc_thread_mutex_lock (mux_display
);
18670 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18671 if (quiet
== 0) fflush (stdout
);
18683 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18684 if (quiet
== 0) fflush (stdout
);
18696 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18697 if (quiet
== 0) fflush (stdout
);
18709 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18710 if (quiet
== 0) fflush (stdout
);
18718 if (benchmark
== 1) break;
18720 stop_at_checkpoint ();
18724 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18725 if (quiet
== 0) fflush (stdout
);
18733 if (benchmark
== 1)
18745 hc_thread_mutex_unlock (mux_display
);
18757 bool class_num (char c
)
18759 return ((c
>= '0') && (c
<= '9'));
18762 bool class_lower (char c
)
18764 return ((c
>= 'a') && (c
<= 'z'));
18767 bool class_upper (char c
)
18769 return ((c
>= 'A') && (c
<= 'Z'));
18772 bool class_alpha (char c
)
18774 return (class_lower (c
) || class_upper (c
));
18777 char conv_ctoi (char c
)
18783 else if (class_upper (c
))
18785 return c
- 'A' + (char) 10;
18788 return (char) (-1);
18791 char conv_itoc (char c
)
18799 return c
+ 'A' - (char) 10;
18802 return (char) (-1);
18809 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18810 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18811 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18812 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18813 #define MAX_GPU_RULES 14
18814 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18815 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18816 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18818 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18819 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18820 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18821 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18823 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18828 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18830 switch (rule_buf
[rule_pos
])
18836 case RULE_OP_MANGLE_NOOP
:
18837 SET_NAME (rule
, rule_buf
[rule_pos
]);
18840 case RULE_OP_MANGLE_LREST
:
18841 SET_NAME (rule
, rule_buf
[rule_pos
]);
18844 case RULE_OP_MANGLE_UREST
:
18845 SET_NAME (rule
, rule_buf
[rule_pos
]);
18848 case RULE_OP_MANGLE_LREST_UFIRST
:
18849 SET_NAME (rule
, rule_buf
[rule_pos
]);
18852 case RULE_OP_MANGLE_UREST_LFIRST
:
18853 SET_NAME (rule
, rule_buf
[rule_pos
]);
18856 case RULE_OP_MANGLE_TREST
:
18857 SET_NAME (rule
, rule_buf
[rule_pos
]);
18860 case RULE_OP_MANGLE_TOGGLE_AT
:
18861 SET_NAME (rule
, rule_buf
[rule_pos
]);
18862 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18865 case RULE_OP_MANGLE_REVERSE
:
18866 SET_NAME (rule
, rule_buf
[rule_pos
]);
18869 case RULE_OP_MANGLE_DUPEWORD
:
18870 SET_NAME (rule
, rule_buf
[rule_pos
]);
18873 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18874 SET_NAME (rule
, rule_buf
[rule_pos
]);
18875 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18878 case RULE_OP_MANGLE_REFLECT
:
18879 SET_NAME (rule
, rule_buf
[rule_pos
]);
18882 case RULE_OP_MANGLE_ROTATE_LEFT
:
18883 SET_NAME (rule
, rule_buf
[rule_pos
]);
18886 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18887 SET_NAME (rule
, rule_buf
[rule_pos
]);
18890 case RULE_OP_MANGLE_APPEND
:
18891 SET_NAME (rule
, rule_buf
[rule_pos
]);
18892 SET_P0 (rule
, rule_buf
[rule_pos
]);
18895 case RULE_OP_MANGLE_PREPEND
:
18896 SET_NAME (rule
, rule_buf
[rule_pos
]);
18897 SET_P0 (rule
, rule_buf
[rule_pos
]);
18900 case RULE_OP_MANGLE_DELETE_FIRST
:
18901 SET_NAME (rule
, rule_buf
[rule_pos
]);
18904 case RULE_OP_MANGLE_DELETE_LAST
:
18905 SET_NAME (rule
, rule_buf
[rule_pos
]);
18908 case RULE_OP_MANGLE_DELETE_AT
:
18909 SET_NAME (rule
, rule_buf
[rule_pos
]);
18910 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18913 case RULE_OP_MANGLE_EXTRACT
:
18914 SET_NAME (rule
, rule_buf
[rule_pos
]);
18915 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18916 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18919 case RULE_OP_MANGLE_OMIT
:
18920 SET_NAME (rule
, rule_buf
[rule_pos
]);
18921 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18922 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18925 case RULE_OP_MANGLE_INSERT
:
18926 SET_NAME (rule
, rule_buf
[rule_pos
]);
18927 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18928 SET_P1 (rule
, rule_buf
[rule_pos
]);
18931 case RULE_OP_MANGLE_OVERSTRIKE
:
18932 SET_NAME (rule
, rule_buf
[rule_pos
]);
18933 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18934 SET_P1 (rule
, rule_buf
[rule_pos
]);
18937 case RULE_OP_MANGLE_TRUNCATE_AT
:
18938 SET_NAME (rule
, rule_buf
[rule_pos
]);
18939 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18942 case RULE_OP_MANGLE_REPLACE
:
18943 SET_NAME (rule
, rule_buf
[rule_pos
]);
18944 SET_P0 (rule
, rule_buf
[rule_pos
]);
18945 SET_P1 (rule
, rule_buf
[rule_pos
]);
18948 case RULE_OP_MANGLE_PURGECHAR
:
18952 case RULE_OP_MANGLE_TOGGLECASE_REC
:
18956 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
18957 SET_NAME (rule
, rule_buf
[rule_pos
]);
18958 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18961 case RULE_OP_MANGLE_DUPECHAR_LAST
:
18962 SET_NAME (rule
, rule_buf
[rule_pos
]);
18963 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18966 case RULE_OP_MANGLE_DUPECHAR_ALL
:
18967 SET_NAME (rule
, rule_buf
[rule_pos
]);
18970 case RULE_OP_MANGLE_SWITCH_FIRST
:
18971 SET_NAME (rule
, rule_buf
[rule_pos
]);
18974 case RULE_OP_MANGLE_SWITCH_LAST
:
18975 SET_NAME (rule
, rule_buf
[rule_pos
]);
18978 case RULE_OP_MANGLE_SWITCH_AT
:
18979 SET_NAME (rule
, rule_buf
[rule_pos
]);
18980 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18981 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18984 case RULE_OP_MANGLE_CHR_SHIFTL
:
18985 SET_NAME (rule
, rule_buf
[rule_pos
]);
18986 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18989 case RULE_OP_MANGLE_CHR_SHIFTR
:
18990 SET_NAME (rule
, rule_buf
[rule_pos
]);
18991 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18994 case RULE_OP_MANGLE_CHR_INCR
:
18995 SET_NAME (rule
, rule_buf
[rule_pos
]);
18996 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18999 case RULE_OP_MANGLE_CHR_DECR
:
19000 SET_NAME (rule
, rule_buf
[rule_pos
]);
19001 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19004 case RULE_OP_MANGLE_REPLACE_NP1
:
19005 SET_NAME (rule
, rule_buf
[rule_pos
]);
19006 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19009 case RULE_OP_MANGLE_REPLACE_NM1
:
19010 SET_NAME (rule
, rule_buf
[rule_pos
]);
19011 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19014 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19015 SET_NAME (rule
, rule_buf
[rule_pos
]);
19016 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19019 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19020 SET_NAME (rule
, rule_buf
[rule_pos
]);
19021 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19024 case RULE_OP_MANGLE_TITLE
:
19025 SET_NAME (rule
, rule_buf
[rule_pos
]);
19034 if (rule_pos
< rule_len
) return (-1);
19039 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19043 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19047 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19051 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19055 case RULE_OP_MANGLE_NOOP
:
19056 rule_buf
[rule_pos
] = rule_cmd
;
19059 case RULE_OP_MANGLE_LREST
:
19060 rule_buf
[rule_pos
] = rule_cmd
;
19063 case RULE_OP_MANGLE_UREST
:
19064 rule_buf
[rule_pos
] = rule_cmd
;
19067 case RULE_OP_MANGLE_LREST_UFIRST
:
19068 rule_buf
[rule_pos
] = rule_cmd
;
19071 case RULE_OP_MANGLE_UREST_LFIRST
:
19072 rule_buf
[rule_pos
] = rule_cmd
;
19075 case RULE_OP_MANGLE_TREST
:
19076 rule_buf
[rule_pos
] = rule_cmd
;
19079 case RULE_OP_MANGLE_TOGGLE_AT
:
19080 rule_buf
[rule_pos
] = rule_cmd
;
19081 GET_P0_CONV (rule
);
19084 case RULE_OP_MANGLE_REVERSE
:
19085 rule_buf
[rule_pos
] = rule_cmd
;
19088 case RULE_OP_MANGLE_DUPEWORD
:
19089 rule_buf
[rule_pos
] = rule_cmd
;
19092 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19093 rule_buf
[rule_pos
] = rule_cmd
;
19094 GET_P0_CONV (rule
);
19097 case RULE_OP_MANGLE_REFLECT
:
19098 rule_buf
[rule_pos
] = rule_cmd
;
19101 case RULE_OP_MANGLE_ROTATE_LEFT
:
19102 rule_buf
[rule_pos
] = rule_cmd
;
19105 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19106 rule_buf
[rule_pos
] = rule_cmd
;
19109 case RULE_OP_MANGLE_APPEND
:
19110 rule_buf
[rule_pos
] = rule_cmd
;
19114 case RULE_OP_MANGLE_PREPEND
:
19115 rule_buf
[rule_pos
] = rule_cmd
;
19119 case RULE_OP_MANGLE_DELETE_FIRST
:
19120 rule_buf
[rule_pos
] = rule_cmd
;
19123 case RULE_OP_MANGLE_DELETE_LAST
:
19124 rule_buf
[rule_pos
] = rule_cmd
;
19127 case RULE_OP_MANGLE_DELETE_AT
:
19128 rule_buf
[rule_pos
] = rule_cmd
;
19129 GET_P0_CONV (rule
);
19132 case RULE_OP_MANGLE_EXTRACT
:
19133 rule_buf
[rule_pos
] = rule_cmd
;
19134 GET_P0_CONV (rule
);
19135 GET_P1_CONV (rule
);
19138 case RULE_OP_MANGLE_OMIT
:
19139 rule_buf
[rule_pos
] = rule_cmd
;
19140 GET_P0_CONV (rule
);
19141 GET_P1_CONV (rule
);
19144 case RULE_OP_MANGLE_INSERT
:
19145 rule_buf
[rule_pos
] = rule_cmd
;
19146 GET_P0_CONV (rule
);
19150 case RULE_OP_MANGLE_OVERSTRIKE
:
19151 rule_buf
[rule_pos
] = rule_cmd
;
19152 GET_P0_CONV (rule
);
19156 case RULE_OP_MANGLE_TRUNCATE_AT
:
19157 rule_buf
[rule_pos
] = rule_cmd
;
19158 GET_P0_CONV (rule
);
19161 case RULE_OP_MANGLE_REPLACE
:
19162 rule_buf
[rule_pos
] = rule_cmd
;
19167 case RULE_OP_MANGLE_PURGECHAR
:
19171 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19175 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19176 rule_buf
[rule_pos
] = rule_cmd
;
19177 GET_P0_CONV (rule
);
19180 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19181 rule_buf
[rule_pos
] = rule_cmd
;
19182 GET_P0_CONV (rule
);
19185 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19186 rule_buf
[rule_pos
] = rule_cmd
;
19189 case RULE_OP_MANGLE_SWITCH_FIRST
:
19190 rule_buf
[rule_pos
] = rule_cmd
;
19193 case RULE_OP_MANGLE_SWITCH_LAST
:
19194 rule_buf
[rule_pos
] = rule_cmd
;
19197 case RULE_OP_MANGLE_SWITCH_AT
:
19198 rule_buf
[rule_pos
] = rule_cmd
;
19199 GET_P0_CONV (rule
);
19200 GET_P1_CONV (rule
);
19203 case RULE_OP_MANGLE_CHR_SHIFTL
:
19204 rule_buf
[rule_pos
] = rule_cmd
;
19205 GET_P0_CONV (rule
);
19208 case RULE_OP_MANGLE_CHR_SHIFTR
:
19209 rule_buf
[rule_pos
] = rule_cmd
;
19210 GET_P0_CONV (rule
);
19213 case RULE_OP_MANGLE_CHR_INCR
:
19214 rule_buf
[rule_pos
] = rule_cmd
;
19215 GET_P0_CONV (rule
);
19218 case RULE_OP_MANGLE_CHR_DECR
:
19219 rule_buf
[rule_pos
] = rule_cmd
;
19220 GET_P0_CONV (rule
);
19223 case RULE_OP_MANGLE_REPLACE_NP1
:
19224 rule_buf
[rule_pos
] = rule_cmd
;
19225 GET_P0_CONV (rule
);
19228 case RULE_OP_MANGLE_REPLACE_NM1
:
19229 rule_buf
[rule_pos
] = rule_cmd
;
19230 GET_P0_CONV (rule
);
19233 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19234 rule_buf
[rule_pos
] = rule_cmd
;
19235 GET_P0_CONV (rule
);
19238 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19239 rule_buf
[rule_pos
] = rule_cmd
;
19240 GET_P0_CONV (rule
);
19243 case RULE_OP_MANGLE_TITLE
:
19244 rule_buf
[rule_pos
] = rule_cmd
;
19248 return rule_pos
- 1;
19266 * CPU rules : this is from hashcat sources, cpu based rules
19269 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19270 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19272 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19273 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19274 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19276 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19277 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19278 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19280 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19284 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19289 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19293 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19298 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19302 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19307 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19312 for (l
= 0; l
< arr_len
; l
++)
19314 r
= arr_len
- 1 - l
;
19318 MANGLE_SWITCH (arr
, l
, r
);
19324 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19326 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19328 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19330 return (arr_len
* 2);
19333 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19335 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19337 int orig_len
= arr_len
;
19341 for (i
= 0; i
< times
; i
++)
19343 memcpy (&arr
[arr_len
], arr
, orig_len
);
19345 arr_len
+= orig_len
;
19351 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19353 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19355 mangle_double (arr
, arr_len
);
19357 mangle_reverse (arr
+ arr_len
, arr_len
);
19359 return (arr_len
* 2);
19362 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19367 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19369 MANGLE_SWITCH (arr
, l
, r
);
19375 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19380 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19382 MANGLE_SWITCH (arr
, l
, r
);
19388 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19390 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19394 return (arr_len
+ 1);
19397 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19399 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19403 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19405 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19410 return (arr_len
+ 1);
19413 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19415 if (upos
>= arr_len
) return (arr_len
);
19419 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19421 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19424 return (arr_len
- 1);
19427 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19429 if (upos
>= arr_len
) return (arr_len
);
19431 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19435 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19437 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19443 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19445 if (upos
>= arr_len
) return (arr_len
);
19447 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19451 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19453 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19456 return (arr_len
- ulen
);
19459 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19461 if (upos
>= arr_len
) return (arr_len
);
19463 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19467 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19469 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19474 return (arr_len
+ 1);
19477 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
)
19479 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19481 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19483 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19485 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19487 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19489 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19491 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19493 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19495 return (arr_len
+ arr2_cpy
);
19498 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19500 if (upos
>= arr_len
) return (arr_len
);
19507 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19509 if (upos
>= arr_len
) return (arr_len
);
19511 memset (arr
+ upos
, 0, arr_len
- upos
);
19516 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19520 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19522 if (arr
[arr_pos
] != oldc
) continue;
19524 arr
[arr_pos
] = newc
;
19530 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19536 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19538 if (arr
[arr_pos
] == c
) continue;
19540 arr
[ret_len
] = arr
[arr_pos
];
19548 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19550 if (ulen
> arr_len
) return (arr_len
);
19552 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19556 memcpy (cs
, arr
, ulen
);
19560 for (i
= 0; i
< ulen
; i
++)
19564 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19570 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19572 if (ulen
> arr_len
) return (arr_len
);
19574 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19576 int upos
= arr_len
- ulen
;
19580 for (i
= 0; i
< ulen
; i
++)
19582 char c
= arr
[upos
+ i
];
19584 arr_len
= mangle_append (arr
, arr_len
, c
);
19590 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19592 if ( arr_len
== 0) return (arr_len
);
19593 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19595 char c
= arr
[upos
];
19599 for (i
= 0; i
< ulen
; i
++)
19601 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19607 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19609 if ( arr_len
== 0) return (arr_len
);
19610 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19614 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19616 int new_pos
= arr_pos
* 2;
19618 arr
[new_pos
] = arr
[arr_pos
];
19620 arr
[new_pos
+ 1] = arr
[arr_pos
];
19623 return (arr_len
* 2);
19626 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19628 if (upos
>= arr_len
) return (arr_len
);
19629 if (upos2
>= arr_len
) return (arr_len
);
19631 MANGLE_SWITCH (arr
, upos
, upos2
);
19636 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19638 MANGLE_SWITCH (arr
, upos
, upos2
);
19643 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19645 if (upos
>= arr_len
) return (arr_len
);
19652 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19654 if (upos
>= arr_len
) return (arr_len
);
19661 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19663 if (upos
>= arr_len
) return (arr_len
);
19670 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19672 if (upos
>= arr_len
) return (arr_len
);
19679 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19681 int upper_next
= 1;
19685 for (pos
= 0; pos
< arr_len
; pos
++)
19687 if (arr
[pos
] == ' ')
19698 MANGLE_UPPER_AT (arr
, pos
);
19702 MANGLE_LOWER_AT (arr
, pos
);
19709 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19711 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19715 uint32_t rule_pos
= 0;
19717 for (j
= 0; j
< rp_gen_num
; j
++)
19724 switch ((char) get_random_num (0, 9))
19727 r
= get_random_num (0, sizeof (grp_op_nop
));
19728 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19732 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19733 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19734 p1
= get_random_num (0, sizeof (grp_pos
));
19735 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19739 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19740 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19741 p1
= get_random_num (1, 6);
19742 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19746 r
= get_random_num (0, sizeof (grp_op_chr
));
19747 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19748 p1
= get_random_num (0x20, 0x7e);
19749 rule_buf
[rule_pos
++] = (char) p1
;
19753 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19754 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19755 p1
= get_random_num (0x20, 0x7e);
19756 rule_buf
[rule_pos
++] = (char) p1
;
19757 p2
= get_random_num (0x20, 0x7e);
19759 p2
= get_random_num (0x20, 0x7e);
19760 rule_buf
[rule_pos
++] = (char) p2
;
19764 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19765 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19766 p1
= get_random_num (0, sizeof (grp_pos
));
19767 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19768 p2
= get_random_num (0x20, 0x7e);
19769 rule_buf
[rule_pos
++] = (char) p2
;
19773 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19774 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19775 p1
= get_random_num (0, sizeof (grp_pos
));
19776 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19777 p2
= get_random_num (0, sizeof (grp_pos
));
19779 p2
= get_random_num (0, sizeof (grp_pos
));
19780 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19784 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19785 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19786 p1
= get_random_num (0, sizeof (grp_pos
));
19787 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19788 p2
= get_random_num (1, sizeof (grp_pos
));
19790 p2
= get_random_num (1, sizeof (grp_pos
));
19791 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19795 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19796 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19797 p1
= get_random_num (0, sizeof (grp_pos
));
19798 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19799 p2
= get_random_num (1, sizeof (grp_pos
));
19800 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19801 p3
= get_random_num (0, sizeof (grp_pos
));
19802 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19810 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19812 char mem
[BLOCK_SIZE
];
19814 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19816 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19818 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19820 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19822 int out_len
= in_len
;
19823 int mem_len
= in_len
;
19825 memcpy (out
, in
, out_len
);
19829 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19831 int upos
; int upos2
;
19834 switch (rule
[rule_pos
])
19839 case RULE_OP_MANGLE_NOOP
:
19842 case RULE_OP_MANGLE_LREST
:
19843 out_len
= mangle_lrest (out
, out_len
);
19846 case RULE_OP_MANGLE_UREST
:
19847 out_len
= mangle_urest (out
, out_len
);
19850 case RULE_OP_MANGLE_LREST_UFIRST
:
19851 out_len
= mangle_lrest (out
, out_len
);
19852 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19855 case RULE_OP_MANGLE_UREST_LFIRST
:
19856 out_len
= mangle_urest (out
, out_len
);
19857 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19860 case RULE_OP_MANGLE_TREST
:
19861 out_len
= mangle_trest (out
, out_len
);
19864 case RULE_OP_MANGLE_TOGGLE_AT
:
19865 NEXT_RULEPOS (rule_pos
);
19866 NEXT_RPTOI (rule
, rule_pos
, upos
);
19867 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19870 case RULE_OP_MANGLE_REVERSE
:
19871 out_len
= mangle_reverse (out
, out_len
);
19874 case RULE_OP_MANGLE_DUPEWORD
:
19875 out_len
= mangle_double (out
, out_len
);
19878 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19879 NEXT_RULEPOS (rule_pos
);
19880 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19881 out_len
= mangle_double_times (out
, out_len
, ulen
);
19884 case RULE_OP_MANGLE_REFLECT
:
19885 out_len
= mangle_reflect (out
, out_len
);
19888 case RULE_OP_MANGLE_ROTATE_LEFT
:
19889 mangle_rotate_left (out
, out_len
);
19892 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19893 mangle_rotate_right (out
, out_len
);
19896 case RULE_OP_MANGLE_APPEND
:
19897 NEXT_RULEPOS (rule_pos
);
19898 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19901 case RULE_OP_MANGLE_PREPEND
:
19902 NEXT_RULEPOS (rule_pos
);
19903 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19906 case RULE_OP_MANGLE_DELETE_FIRST
:
19907 out_len
= mangle_delete_at (out
, out_len
, 0);
19910 case RULE_OP_MANGLE_DELETE_LAST
:
19911 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19914 case RULE_OP_MANGLE_DELETE_AT
:
19915 NEXT_RULEPOS (rule_pos
);
19916 NEXT_RPTOI (rule
, rule_pos
, upos
);
19917 out_len
= mangle_delete_at (out
, out_len
, upos
);
19920 case RULE_OP_MANGLE_EXTRACT
:
19921 NEXT_RULEPOS (rule_pos
);
19922 NEXT_RPTOI (rule
, rule_pos
, upos
);
19923 NEXT_RULEPOS (rule_pos
);
19924 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19925 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19928 case RULE_OP_MANGLE_OMIT
:
19929 NEXT_RULEPOS (rule_pos
);
19930 NEXT_RPTOI (rule
, rule_pos
, upos
);
19931 NEXT_RULEPOS (rule_pos
);
19932 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19933 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19936 case RULE_OP_MANGLE_INSERT
:
19937 NEXT_RULEPOS (rule_pos
);
19938 NEXT_RPTOI (rule
, rule_pos
, upos
);
19939 NEXT_RULEPOS (rule_pos
);
19940 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19943 case RULE_OP_MANGLE_OVERSTRIKE
:
19944 NEXT_RULEPOS (rule_pos
);
19945 NEXT_RPTOI (rule
, rule_pos
, upos
);
19946 NEXT_RULEPOS (rule_pos
);
19947 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
19950 case RULE_OP_MANGLE_TRUNCATE_AT
:
19951 NEXT_RULEPOS (rule_pos
);
19952 NEXT_RPTOI (rule
, rule_pos
, upos
);
19953 out_len
= mangle_truncate_at (out
, out_len
, upos
);
19956 case RULE_OP_MANGLE_REPLACE
:
19957 NEXT_RULEPOS (rule_pos
);
19958 NEXT_RULEPOS (rule_pos
);
19959 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
19962 case RULE_OP_MANGLE_PURGECHAR
:
19963 NEXT_RULEPOS (rule_pos
);
19964 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
19967 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19971 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19972 NEXT_RULEPOS (rule_pos
);
19973 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19974 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
19977 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19978 NEXT_RULEPOS (rule_pos
);
19979 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19980 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
19983 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19984 out_len
= mangle_dupechar (out
, out_len
);
19987 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19988 NEXT_RULEPOS (rule_pos
);
19989 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19990 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
19993 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19994 NEXT_RULEPOS (rule_pos
);
19995 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19996 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
19999 case RULE_OP_MANGLE_SWITCH_FIRST
:
20000 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20003 case RULE_OP_MANGLE_SWITCH_LAST
:
20004 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20007 case RULE_OP_MANGLE_SWITCH_AT
:
20008 NEXT_RULEPOS (rule_pos
);
20009 NEXT_RPTOI (rule
, rule_pos
, upos
);
20010 NEXT_RULEPOS (rule_pos
);
20011 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20012 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20015 case RULE_OP_MANGLE_CHR_SHIFTL
:
20016 NEXT_RULEPOS (rule_pos
);
20017 NEXT_RPTOI (rule
, rule_pos
, upos
);
20018 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20021 case RULE_OP_MANGLE_CHR_SHIFTR
:
20022 NEXT_RULEPOS (rule_pos
);
20023 NEXT_RPTOI (rule
, rule_pos
, upos
);
20024 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20027 case RULE_OP_MANGLE_CHR_INCR
:
20028 NEXT_RULEPOS (rule_pos
);
20029 NEXT_RPTOI (rule
, rule_pos
, upos
);
20030 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20033 case RULE_OP_MANGLE_CHR_DECR
:
20034 NEXT_RULEPOS (rule_pos
);
20035 NEXT_RPTOI (rule
, rule_pos
, upos
);
20036 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20039 case RULE_OP_MANGLE_REPLACE_NP1
:
20040 NEXT_RULEPOS (rule_pos
);
20041 NEXT_RPTOI (rule
, rule_pos
, upos
);
20042 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20045 case RULE_OP_MANGLE_REPLACE_NM1
:
20046 NEXT_RULEPOS (rule_pos
);
20047 NEXT_RPTOI (rule
, rule_pos
, upos
);
20048 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20051 case RULE_OP_MANGLE_TITLE
:
20052 out_len
= mangle_title (out
, out_len
);
20055 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20056 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20057 NEXT_RULEPOS (rule_pos
);
20058 NEXT_RPTOI (rule
, rule_pos
, upos
);
20059 NEXT_RULEPOS (rule_pos
);
20060 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20061 NEXT_RULEPOS (rule_pos
);
20062 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20063 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20066 case RULE_OP_MANGLE_APPEND_MEMORY
:
20067 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20068 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20069 memcpy (out
+ out_len
, mem
, mem_len
);
20070 out_len
+= mem_len
;
20073 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20074 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20075 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20076 memcpy (mem
+ mem_len
, out
, out_len
);
20077 out_len
+= mem_len
;
20078 memcpy (out
, mem
, out_len
);
20081 case RULE_OP_MEMORIZE_WORD
:
20082 memcpy (mem
, out
, out_len
);
20086 case RULE_OP_REJECT_LESS
:
20087 NEXT_RULEPOS (rule_pos
);
20088 NEXT_RPTOI (rule
, rule_pos
, upos
);
20089 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20092 case RULE_OP_REJECT_GREATER
:
20093 NEXT_RULEPOS (rule_pos
);
20094 NEXT_RPTOI (rule
, rule_pos
, upos
);
20095 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20098 case RULE_OP_REJECT_CONTAIN
:
20099 NEXT_RULEPOS (rule_pos
);
20100 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20103 case RULE_OP_REJECT_NOT_CONTAIN
:
20104 NEXT_RULEPOS (rule_pos
);
20105 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20108 case RULE_OP_REJECT_EQUAL_FIRST
:
20109 NEXT_RULEPOS (rule_pos
);
20110 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20113 case RULE_OP_REJECT_EQUAL_LAST
:
20114 NEXT_RULEPOS (rule_pos
);
20115 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20118 case RULE_OP_REJECT_EQUAL_AT
:
20119 NEXT_RULEPOS (rule_pos
);
20120 NEXT_RPTOI (rule
, rule_pos
, upos
);
20121 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20122 NEXT_RULEPOS (rule_pos
);
20123 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20126 case RULE_OP_REJECT_CONTAINS
:
20127 NEXT_RULEPOS (rule_pos
);
20128 NEXT_RPTOI (rule
, rule_pos
, upos
);
20129 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20130 NEXT_RULEPOS (rule_pos
);
20131 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20132 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20135 case RULE_OP_REJECT_MEMORY
:
20136 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20140 return (RULE_RC_SYNTAX_ERROR
);
20145 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);