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 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2663 //can be used to determine if the device by index matches the cuda device by index
2664 //char name[100]; memset (name, 0, sizeof (name));
2665 //hc_NVML_nvmlDeviceGetName (data.hm_dll, nvGPUHandle[i], name, sizeof (name) - 1);
2672 log_info ("WARN: No NVML adapters found");
2681 void hm_close (HM_LIB hm_dll
)
2687 FreeLibrary (hm_dll
);
2694 HM_LIB hm_dll
= NULL
;
2696 if (data
.vendor_id
== VENDOR_ID_AMD
)
2699 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2702 hm_dll
= LoadLibrary ("atiadlxx.dll");
2706 hm_dll
= LoadLibrary ("atiadlxy.dll");
2713 if (data
.vendor_id
== VENDOR_ID_NV
)
2715 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2722 int get_adapters_num_amd (HM_LIB hm_dll
, int *iNumberAdapters
)
2724 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll
, iNumberAdapters
) != ADL_OK
) return -1;
2726 if (iNumberAdapters
== 0)
2728 log_info ("WARN: No ADL adapters found.");
2737 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2739 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2740 ADLODParameters lpOdParameters;
2742 lpOdParameters.iSize = sizeof (ADLODParameters);
2743 size_t plevels_size = 0;
2745 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2747 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2748 __func__, iAdapterIndex,
2749 lpOdParameters.iNumberOfPerformanceLevels,
2750 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2751 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2753 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2755 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2757 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2759 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2761 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2762 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2763 __func__, iAdapterIndex, j,
2764 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2766 myfree (lpOdPerformanceLevels);
2772 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll
, int iNumberAdapters
)
2774 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2776 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2778 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2780 return lpAdapterInfo
;
2785 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2788 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2792 for (uint i = 0; i < num_adl_adapters; i++)
2794 int opencl_bus_num = hm_device[i].busid;
2795 int opencl_dev_num = hm_device[i].devid;
2797 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2805 if (idx >= DEVICES_MAX) return -1;
2810 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2812 for (uint i = 0; i < opencl_num_devices; i++)
2814 cl_device_topology_amd device_topology;
2816 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2818 hm_device[i].busid = device_topology.pcie.bus;
2819 hm_device[i].devid = device_topology.pcie.device;
2824 void hm_sort_adl_adapters_by_busid_devid (uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2826 // basically bubble sort
2828 for (int i
= 0; i
< num_adl_adapters
; i
++)
2830 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2832 // get info of adapter [x]
2834 uint32_t adapter_index_x
= valid_adl_device_list
[j
];
2835 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2837 uint32_t bus_num_x
= info_x
.iBusNumber
;
2838 uint32_t dev_num_x
= info_x
.iDeviceNumber
;
2840 // get info of adapter [y]
2842 uint32_t adapter_index_y
= valid_adl_device_list
[j
+ 1];
2843 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2845 uint32_t bus_num_y
= info_y
.iBusNumber
;
2846 uint32_t dev_num_y
= info_y
.iDeviceNumber
;
2850 if (bus_num_y
< bus_num_x
)
2854 else if (bus_num_y
== bus_num_x
)
2856 if (dev_num_y
< dev_num_x
)
2864 uint32_t temp
= valid_adl_device_list
[j
+ 1];
2866 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2867 valid_adl_device_list
[j
+ 0] = temp
;
2873 uint32_t *hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2875 *num_adl_adapters
= 0;
2877 uint32_t *adl_adapters
= NULL
;
2879 int *bus_numbers
= NULL
;
2880 int *device_numbers
= NULL
;
2882 for (int i
= 0; i
< iNumberAdapters
; i
++)
2884 AdapterInfo info
= lpAdapterInfo
[i
];
2886 if ((info
.strUDID
== NULL
) || (strlen (info
.strUDID
) < 1)) continue;
2889 if (info
.iVendorID
!= 1002) continue;
2891 if (info
.iVendorID
!= 0x1002) continue;
2894 if (info
.iBusNumber
< 0) continue;
2895 if (info
.iDeviceNumber
< 0) continue;
2899 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2901 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2908 if (found
) continue;
2910 // add it to the list
2912 adl_adapters
= (uint32_t *) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2914 adl_adapters
[*num_adl_adapters
] = i
;
2916 // rest is just bookkeeping
2918 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2921 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2922 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2924 (*num_adl_adapters
)++;
2927 myfree (bus_numbers
);
2928 myfree (device_numbers
);
2930 // sort the list by increasing bus id, device id number
2932 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2934 return adl_adapters
;
2937 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
)
2939 // loop through all valid devices
2941 for (int i
= 0; i
< num_adl_adapters
; i
++)
2943 uint32_t adapter_index
= valid_adl_device_list
[i
];
2947 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2949 // unfortunately this doesn't work since bus id and dev id are not unique
2950 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2951 // if (opencl_device_index == -1) continue;
2953 int opencl_device_index
= i
;
2955 // if (hm_show_performance_level (hm_dll, info.iAdapterIndex) != 0) return -1;
2957 // get fanspeed info
2959 if (hm_device
[opencl_device_index
].od_version
== 5)
2961 ADLFanSpeedInfo FanSpeedInfo
;
2963 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2965 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2967 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2969 // check read and write capability in fanspeedinfo
2971 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2972 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2974 hm_device
[opencl_device_index
].fan_supported
= 1;
2978 hm_device
[opencl_device_index
].fan_supported
= 0;
2981 else // od_version == 6
2983 ADLOD6FanSpeedInfo faninfo
;
2985 memset (&faninfo
, 0, sizeof (faninfo
));
2987 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2989 // check read capability in fanspeedinfo
2991 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2993 hm_device
[opencl_device_index
].fan_supported
= 1;
2997 hm_device
[opencl_device_index
].fan_supported
= 0;
3005 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
)
3007 for (int i
= 0; i
< num_adl_adapters
; i
++)
3009 uint32_t adapter_index
= valid_adl_device_list
[i
];
3013 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3015 // get overdrive version
3017 int od_supported
= 0;
3021 if (hc_ADL_Overdrive_Caps (hm_dll
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3023 // store the overdrive version in hm_device
3025 // unfortunately this doesn't work since bus id and dev id are not unique
3026 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3027 // if (opencl_device_index == -1) continue;
3029 int opencl_device_index
= i
;
3031 hm_device
[opencl_device_index
].od_version
= od_version
;
3037 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3039 for (int i
= 0; i
< num_adl_adapters
; i
++)
3041 uint32_t adapter_index
= valid_adl_device_list
[i
];
3045 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3047 // store the iAdapterIndex in hm_device
3049 // unfortunately this doesn't work since bus id and dev id are not unique
3050 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3051 // if (opencl_device_index == -1) continue;
3053 int opencl_device_index
= i
;
3055 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3058 return num_adl_adapters
;
3061 int hm_get_temperature_with_device_id (const uint device_id
)
3063 if (data
.vendor_id
== VENDOR_ID_AMD
)
3067 if (data
.hm_device
[device_id
].od_version
== 5)
3069 ADLTemperature Temperature
;
3071 Temperature
.iSize
= sizeof (ADLTemperature
);
3073 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3075 return Temperature
.iTemperature
/ 1000;
3077 else if (data
.hm_device
[device_id
].od_version
== 6)
3079 int Temperature
= 0;
3081 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3083 return Temperature
/ 1000;
3088 if (data
.vendor_id
== VENDOR_ID_NV
)
3091 int temperature
= 0;
3093 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3099 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3101 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3102 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3103 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3104 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3106 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3108 return pThermalSettings
.sensor
[0].currentTemp
;
3115 int hm_get_fanspeed_with_device_id (const uint device_id
)
3117 if (data
.hm_device
[device_id
].fan_supported
== 1)
3119 if (data
.vendor_id
== VENDOR_ID_AMD
)
3123 if (data
.hm_device
[device_id
].od_version
== 5)
3125 ADLFanSpeedValue lpFanSpeedValue
;
3127 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3129 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3130 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3131 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3133 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3135 return lpFanSpeedValue
.iFanSpeed
;
3137 else // od_version == 6
3139 ADLOD6FanSpeedInfo faninfo
;
3141 memset (&faninfo
, 0, sizeof (faninfo
));
3143 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3145 return faninfo
.iFanSpeedPercent
;
3150 if (data
.vendor_id
== VENDOR_ID_NV
)
3155 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3163 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3173 int hm_get_utilization_with_device_id (const uint device_id
)
3175 if (data
.vendor_id
== VENDOR_ID_AMD
)
3179 ADLPMActivity PMActivity
;
3181 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3183 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3185 return PMActivity
.iActivityPercent
;
3189 if (data
.vendor_id
== VENDOR_ID_NV
)
3192 nvmlUtilization_t utilization
;
3194 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3196 return utilization
.gpu
;
3200 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3202 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3204 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3206 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3213 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3215 if (data
.hm_device
[device_id
].fan_supported
== 1)
3219 if (data
.hm_device
[device_id
].od_version
== 5)
3221 ADLFanSpeedValue lpFanSpeedValue
;
3223 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3225 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3226 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3227 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3228 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3230 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3234 else // od_version == 6
3236 ADLOD6FanSpeedValue fan_speed_value
;
3238 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3240 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3241 fan_speed_value
.iFanSpeed
= fanspeed
;
3243 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3257 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3259 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3261 if (css_cnt
> SP_PW_MAX
)
3263 log_error ("ERROR: mask length is too long");
3268 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3270 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3272 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3273 uint cs_len
= css
[css_pos
].cs_len
;
3275 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3277 uint c
= cs_buf
[cs_pos
] & 0xff;
3284 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3286 cs_t
*cs
= &css
[css_cnt
];
3288 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3290 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3292 memset (css_uniq
, 0, css_uniq_sz
);
3296 for (i
= 0; i
< cs
->cs_len
; i
++)
3298 const uint u
= cs
->cs_buf
[i
];
3303 for (i
= 0; i
< in_len
; i
++)
3305 uint u
= in_buf
[i
] & 0xff;
3307 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3309 if (css_uniq
[u
] == 1) continue;
3313 cs
->cs_buf
[cs
->cs_len
] = u
;
3321 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3325 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3327 uint p0
= in_buf
[in_pos
] & 0xff;
3329 if (interpret
== 1 && p0
== '?')
3333 if (in_pos
== in_len
) break;
3335 uint p1
= in_buf
[in_pos
] & 0xff;
3339 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3341 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3343 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3345 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3347 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3349 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3351 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3352 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3354 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3355 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3357 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3358 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3360 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3361 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3363 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3365 default: log_error ("Syntax error: %s", in_buf
);
3371 if (data
.hex_charset
)
3375 if (in_pos
== in_len
)
3377 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3382 uint p1
= in_buf
[in_pos
] & 0xff;
3384 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3386 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3393 chr
= hex_convert (p1
) << 0;
3394 chr
|= hex_convert (p0
) << 4;
3396 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3402 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3408 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3412 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3414 sum
*= css
[css_pos
].cs_len
;
3420 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3422 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3427 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3429 char p0
= mask_buf
[mask_pos
];
3435 if (mask_pos
== mask_len
) break;
3437 char p1
= mask_buf
[mask_pos
];
3443 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3445 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3447 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3449 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3451 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3453 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3455 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3456 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3458 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3459 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3461 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3462 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3464 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3465 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3467 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3469 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3475 if (data
.hex_charset
)
3479 // if there is no 2nd hex character, show an error:
3481 if (mask_pos
== mask_len
)
3483 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3488 char p1
= mask_buf
[mask_pos
];
3490 // if they are not valid hex character, show an error:
3492 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3494 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3501 chr
|= hex_convert (p1
) << 0;
3502 chr
|= hex_convert (p0
) << 4;
3504 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3517 log_error ("ERROR: invalid mask length (0)");
3527 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3529 for (int i
= 0; i
< css_cnt
; i
++)
3531 uint len
= css
[i
].cs_len
;
3532 uint64_t next
= val
/ len
;
3533 uint pos
= val
% len
;
3534 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3539 void mp_cut_at (char *mask
, uint max
)
3543 uint mask_len
= strlen (mask
);
3545 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3547 if (mask
[i
] == '?') i
++;
3553 void mp_setup_sys (cs_t
*mp_sys
)
3557 uint donec
[CHARSIZ
];
3559 memset (donec
, 0, sizeof (donec
));
3561 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3562 mp_sys
[0].cs_buf
[pos
++] = chr
;
3563 mp_sys
[0].cs_len
= pos
; }
3565 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3566 mp_sys
[1].cs_buf
[pos
++] = chr
;
3567 mp_sys
[1].cs_len
= pos
; }
3569 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3570 mp_sys
[2].cs_buf
[pos
++] = chr
;
3571 mp_sys
[2].cs_len
= pos
; }
3573 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3574 mp_sys
[3].cs_buf
[pos
++] = chr
;
3575 mp_sys
[3].cs_len
= pos
; }
3577 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3578 mp_sys
[4].cs_len
= pos
; }
3580 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3581 mp_sys
[5].cs_len
= pos
; }
3584 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3586 FILE *fp
= fopen (buf
, "rb");
3588 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3590 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3596 memset (mp_file
, 0, sizeof (mp_file
));
3598 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3602 len
= in_superchop (mp_file
);
3606 log_info ("WARNING: charset file corrupted");
3608 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3612 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3617 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3619 mp_usr
[index
].cs_len
= 0;
3621 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3624 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3626 char *new_mask_buf
= (char *) mymalloc (256);
3632 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3634 if (css_pos
== len
) break;
3636 char p0
= mask_buf
[mask_pos
];
3638 new_mask_buf
[mask_pos
] = p0
;
3644 if (mask_pos
== mask_len
) break;
3646 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3650 if (data
.hex_charset
)
3654 if (mask_pos
== mask_len
)
3656 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3661 char p1
= mask_buf
[mask_pos
];
3663 // if they are not valid hex character, show an error:
3665 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3667 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3672 new_mask_buf
[mask_pos
] = p1
;
3677 if (css_pos
== len
) return (new_mask_buf
);
3679 myfree (new_mask_buf
);
3688 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3694 for (i
= start
; i
< stop
; i
++)
3696 sum
*= root_css_buf
[i
].cs_len
;
3702 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3706 cs_t
*cs
= &root_css_buf
[start
];
3710 for (i
= start
; i
< stop
; i
++)
3712 const uint64_t m
= v
% cs
->cs_len
;
3713 const uint64_t d
= v
/ cs
->cs_len
;
3717 const uint k
= cs
->cs_buf
[m
];
3719 pw_buf
[i
- start
] = (char) k
;
3721 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3725 int sp_comp_val (const void *p1
, const void *p2
)
3727 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3728 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3730 return b2
->val
- b1
->val
;
3733 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3740 * Initialize hcstats
3743 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3745 uint64_t *root_stats_ptr
= root_stats_buf
;
3747 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3749 for (i
= 0; i
< SP_PW_MAX
; i
++)
3751 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3753 root_stats_ptr
+= CHARSIZ
;
3756 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3758 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3760 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3762 for (i
= 0; i
< SP_PW_MAX
; i
++)
3764 for (j
= 0; j
< CHARSIZ
; j
++)
3766 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3768 markov_stats_ptr
+= CHARSIZ
;
3778 char hcstat_tmp
[256];
3780 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3782 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3784 hcstat
= hcstat_tmp
;
3787 FILE *fd
= fopen (hcstat
, "rb");
3791 log_error ("%s: %s", hcstat
, strerror (errno
));
3796 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3798 log_error ("%s: Could not load data", hcstat
);
3803 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3805 log_error ("%s: Could not load data", hcstat
);
3813 * Markov modifier of hcstat_table on user request
3818 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3819 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3824 /* Add all stats to first position */
3826 for (i
= 1; i
< SP_PW_MAX
; i
++)
3828 uint64_t *out
= root_stats_buf_by_pos
[0];
3829 uint64_t *in
= root_stats_buf_by_pos
[i
];
3831 for (j
= 0; j
< CHARSIZ
; j
++)
3837 for (i
= 1; i
< SP_PW_MAX
; i
++)
3839 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3840 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3842 for (j
= 0; j
< CHARSIZ
; j
++)
3844 for (k
= 0; k
< CHARSIZ
; k
++)
3851 /* copy them to all pw_positions */
3853 for (i
= 1; i
< SP_PW_MAX
; i
++)
3855 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3858 for (i
= 1; i
< SP_PW_MAX
; i
++)
3860 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3868 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3870 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3872 for (i
= 0; i
< SP_PW_MAX
; i
++)
3874 root_table_buf_by_pos
[i
] = root_table_ptr
;
3876 root_table_ptr
+= CHARSIZ
;
3879 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3881 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3883 for (i
= 0; i
< SP_PW_MAX
; i
++)
3885 for (j
= 0; j
< CHARSIZ
; j
++)
3887 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3889 markov_table_ptr
+= CHARSIZ
;
3894 * Convert hcstat to tables
3897 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3899 uint key
= i
% CHARSIZ
;
3901 root_table_buf
[i
].key
= key
;
3902 root_table_buf
[i
].val
= root_stats_buf
[i
];
3905 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3907 uint key
= i
% CHARSIZ
;
3909 markov_table_buf
[i
].key
= key
;
3910 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3913 myfree (root_stats_buf
);
3914 myfree (markov_stats_buf
);
3920 for (i
= 0; i
< SP_PW_MAX
; i
++)
3922 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3925 for (i
= 0; i
< SP_PW_MAX
; i
++)
3927 for (j
= 0; j
< CHARSIZ
; j
++)
3929 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3934 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
])
3937 * Convert tables to css
3940 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3942 uint pw_pos
= i
/ CHARSIZ
;
3944 cs_t
*cs
= &root_css_buf
[pw_pos
];
3946 if (cs
->cs_len
== threshold
) continue;
3948 uint key
= root_table_buf
[i
].key
;
3950 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3952 cs
->cs_buf
[cs
->cs_len
] = key
;
3958 * Convert table to css
3961 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3963 uint c
= i
/ CHARSIZ
;
3965 cs_t
*cs
= &markov_css_buf
[c
];
3967 if (cs
->cs_len
== threshold
) continue;
3969 uint pw_pos
= c
/ CHARSIZ
;
3971 uint key
= markov_table_buf
[i
].key
;
3973 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3975 cs
->cs_buf
[cs
->cs_len
] = key
;
3981 for (uint i = 0; i < 8; i++)
3983 for (uint j = 0x20; j < 0x80; j++)
3985 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
3987 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
3989 for (uint k = 0; k < 10; k++)
3991 printf (" %u\n", ptr->cs_buf[k]);
3998 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4000 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4002 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4012 for (uint j
= 1; j
< CHARSIZ
; j
++)
4022 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4024 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4026 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4028 out
+= CHARSIZ
* CHARSIZ
;
4029 in
+= CHARSIZ
* CHARSIZ
;
4031 for (uint j
= 0; j
< CHARSIZ
; j
++)
4038 for (uint k
= 1; k
< CHARSIZ
; k
++)
4050 * mixed shared functions
4053 void dump_hex (const char *s
, size_t size
)
4057 for (i
= 0; i
< size
; i
++)
4059 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4065 void usage_mini_print (const char *progname
)
4067 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4070 void usage_big_print (const char *progname
)
4072 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4075 char *get_exec_path ()
4077 int exec_path_len
= 1024;
4079 char *exec_path
= (char *) mymalloc (exec_path_len
);
4085 sprintf (tmp
, "/proc/%d/exe", getpid ());
4087 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4093 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4102 char *get_install_dir (const char *progname
)
4104 char *install_dir
= mystrdup (progname
);
4105 char *last_slash
= NULL
;
4107 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4111 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4117 install_dir
[0] = '.';
4121 return (install_dir
);
4124 char *get_profile_dir (const char *homedir
)
4126 #define DOT_HASHCAT ".hashcat"
4128 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4130 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4135 char *get_session_dir (const char *profile_dir
, const char *session
)
4137 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (session
) + 1);
4139 sprintf (session_dir
, "%s/%s", profile_dir
, session
);
4144 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4148 FILE *fd
= fopen (file
, "rb");
4152 log_error ("%s: %s", file
, strerror (errno
));
4157 #define MAX_KEY_SIZE (1024 * 1024)
4159 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4161 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4165 for (int fpos
= 0; fpos
< nread
; fpos
++)
4167 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4169 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4170 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4171 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4172 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4174 if (kpos
>= 64) kpos
= 0;
4182 void set_cpu_affinity (char *cpu_affinity
)
4185 DWORD_PTR aff_mask
= 0;
4196 char *devices
= strdup (cpu_affinity
);
4198 char *next
= strtok (devices
, ",");
4202 uint cpu_id
= atoi (next
);
4219 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4225 aff_mask
|= 1 << (cpu_id
- 1);
4229 CPU_SET ((cpu_id
- 1), &cpuset
);
4232 } while ((next
= strtok (NULL
, ",")) != NULL
);
4238 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4239 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4243 pthread_t thread
= pthread_self ();
4244 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4248 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4250 char *element
, *end
;
4252 end
= (char *) base
+ nmemb
* size
;
4254 for (element
= (char *) base
; element
< end
; element
+= size
)
4255 if (!compar (element
, key
))
4261 int sort_by_salt (const void *v1
, const void *v2
)
4263 const salt_t
*s1
= (const salt_t
*) v1
;
4264 const salt_t
*s2
= (const salt_t
*) v2
;
4266 const int res1
= s1
->salt_len
- s2
->salt_len
;
4268 if (res1
!= 0) return (res1
);
4270 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4272 if (res2
!= 0) return (res2
);
4280 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4281 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4288 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4289 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4295 int sort_by_salt_buf (const void *v1
, const void *v2
)
4297 const pot_t
*p1
= (const pot_t
*) v1
;
4298 const pot_t
*p2
= (const pot_t
*) v2
;
4300 const hash_t
*h1
= &p1
->hash
;
4301 const hash_t
*h2
= &p2
->hash
;
4303 const salt_t
*s1
= h1
->salt
;
4304 const salt_t
*s2
= h2
->salt
;
4310 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4311 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4317 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4319 const hash_t
*h1
= (const hash_t
*) v1
;
4320 const hash_t
*h2
= (const hash_t
*) v2
;
4322 const salt_t
*s1
= h1
->salt
;
4323 const salt_t
*s2
= h2
->salt
;
4325 // testphase: this should work
4330 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4331 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4334 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4335 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4336 if (s1->salt_len > s2->salt_len) return ( 1);
4337 if (s1->salt_len < s2->salt_len) return (-1);
4339 uint n = s1->salt_len;
4343 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4344 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4351 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4353 const hash_t
*h1
= (const hash_t
*) v1
;
4354 const hash_t
*h2
= (const hash_t
*) v2
;
4356 const salt_t
*s1
= h1
->salt
;
4357 const salt_t
*s2
= h2
->salt
;
4359 // 12 - 2 (since last 2 uints contain the digest)
4364 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4365 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4371 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4373 const hash_t
*h1
= (const hash_t
*) v1
;
4374 const hash_t
*h2
= (const hash_t
*) v2
;
4376 const void *d1
= h1
->digest
;
4377 const void *d2
= h2
->digest
;
4379 return data
.sort_by_digest (d1
, d2
);
4382 int sort_by_hash (const void *v1
, const void *v2
)
4384 const hash_t
*h1
= (const hash_t
*) v1
;
4385 const hash_t
*h2
= (const hash_t
*) v2
;
4389 const salt_t
*s1
= h1
->salt
;
4390 const salt_t
*s2
= h2
->salt
;
4392 int res
= sort_by_salt (s1
, s2
);
4394 if (res
!= 0) return (res
);
4397 const void *d1
= h1
->digest
;
4398 const void *d2
= h2
->digest
;
4400 return data
.sort_by_digest (d1
, d2
);
4403 int sort_by_pot (const void *v1
, const void *v2
)
4405 const pot_t
*p1
= (const pot_t
*) v1
;
4406 const pot_t
*p2
= (const pot_t
*) v2
;
4408 const hash_t
*h1
= &p1
->hash
;
4409 const hash_t
*h2
= &p2
->hash
;
4411 return sort_by_hash (h1
, h2
);
4414 int sort_by_mtime (const void *p1
, const void *p2
)
4416 const char **f1
= (const char **) p1
;
4417 const char **f2
= (const char **) p2
;
4419 struct stat s1
; stat (*f1
, &s1
);
4420 struct stat s2
; stat (*f2
, &s2
);
4422 return s2
.st_mtime
- s1
.st_mtime
;
4425 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4427 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4428 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4430 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4433 int sort_by_gpu_rule (const void *p1
, const void *p2
)
4435 const gpu_rule_t
*r1
= (const gpu_rule_t
*) p1
;
4436 const gpu_rule_t
*r2
= (const gpu_rule_t
*) p2
;
4438 return memcmp (r1
, r2
, sizeof (gpu_rule_t
));
4441 int sort_by_stringptr (const void *p1
, const void *p2
)
4443 const char **s1
= (const char **) p1
;
4444 const char **s2
= (const char **) p2
;
4446 return strcmp (*s1
, *s2
);
4449 int sort_by_dictstat (const void *s1
, const void *s2
)
4451 dictstat_t
*d1
= (dictstat_t
*) s1
;
4452 dictstat_t
*d2
= (dictstat_t
*) s2
;
4455 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4457 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4460 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4463 int sort_by_bitmap (const void *p1
, const void *p2
)
4465 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4466 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4468 return b1
->collisions
- b2
->collisions
;
4471 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4473 const uint32_t *d1
= (const uint32_t *) v1
;
4474 const uint32_t *d2
= (const uint32_t *) v2
;
4480 if (d1
[n
] > d2
[n
]) return ( 1);
4481 if (d1
[n
] < d2
[n
]) return (-1);
4487 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4489 const uint32_t *d1
= (const uint32_t *) v1
;
4490 const uint32_t *d2
= (const uint32_t *) v2
;
4496 if (d1
[n
] > d2
[n
]) return ( 1);
4497 if (d1
[n
] < d2
[n
]) return (-1);
4503 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4505 const uint32_t *d1
= (const uint32_t *) v1
;
4506 const uint32_t *d2
= (const uint32_t *) v2
;
4512 if (d1
[n
] > d2
[n
]) return ( 1);
4513 if (d1
[n
] < d2
[n
]) return (-1);
4519 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4521 const uint32_t *d1
= (const uint32_t *) v1
;
4522 const uint32_t *d2
= (const uint32_t *) v2
;
4528 if (d1
[n
] > d2
[n
]) return ( 1);
4529 if (d1
[n
] < d2
[n
]) return (-1);
4535 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4537 const uint32_t *d1
= (const uint32_t *) v1
;
4538 const uint32_t *d2
= (const uint32_t *) v2
;
4544 if (d1
[n
] > d2
[n
]) return ( 1);
4545 if (d1
[n
] < d2
[n
]) return (-1);
4551 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4553 const uint32_t *d1
= (const uint32_t *) v1
;
4554 const uint32_t *d2
= (const uint32_t *) v2
;
4560 if (d1
[n
] > d2
[n
]) return ( 1);
4561 if (d1
[n
] < d2
[n
]) return (-1);
4567 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4569 const uint32_t *d1
= (const uint32_t *) v1
;
4570 const uint32_t *d2
= (const uint32_t *) v2
;
4576 if (d1
[n
] > d2
[n
]) return ( 1);
4577 if (d1
[n
] < d2
[n
]) return (-1);
4583 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4585 const uint32_t *d1
= (const uint32_t *) v1
;
4586 const uint32_t *d2
= (const uint32_t *) v2
;
4592 if (d1
[n
] > d2
[n
]) return ( 1);
4593 if (d1
[n
] < d2
[n
]) return (-1);
4599 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4601 const uint64_t *d1
= (const uint64_t *) v1
;
4602 const uint64_t *d2
= (const uint64_t *) v2
;
4608 if (d1
[n
] > d2
[n
]) return ( 1);
4609 if (d1
[n
] < d2
[n
]) return (-1);
4615 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4617 const uint64_t *d1
= (const uint64_t *) v1
;
4618 const uint64_t *d2
= (const uint64_t *) v2
;
4624 if (d1
[n
] > d2
[n
]) return ( 1);
4625 if (d1
[n
] < d2
[n
]) return (-1);
4631 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4633 const uint64_t *d1
= (const uint64_t *) v1
;
4634 const uint64_t *d2
= (const uint64_t *) v2
;
4640 if (d1
[n
] > d2
[n
]) return ( 1);
4641 if (d1
[n
] < d2
[n
]) return (-1);
4647 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4649 const uint32_t *d1
= (const uint32_t *) v1
;
4650 const uint32_t *d2
= (const uint32_t *) v2
;
4652 const uint dgst_pos0
= data
.dgst_pos0
;
4653 const uint dgst_pos1
= data
.dgst_pos1
;
4654 const uint dgst_pos2
= data
.dgst_pos2
;
4655 const uint dgst_pos3
= data
.dgst_pos3
;
4657 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4658 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4659 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4660 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4661 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4662 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4663 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4664 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4669 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
)
4671 uint outfile_autohex
= data
.outfile_autohex
;
4673 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4675 FILE *debug_fp
= NULL
;
4677 if (debug_file
!= NULL
)
4679 debug_fp
= fopen (debug_file
, "ab");
4686 if (debug_fp
== NULL
)
4688 log_info ("WARNING: Could not open debug-file for writing");
4692 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4694 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4696 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4699 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4701 if (debug_mode
== 4)
4703 fputc (':', debug_fp
);
4705 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4708 fputc ('\n', debug_fp
);
4710 if (debug_file
!= NULL
) fclose (debug_fp
);
4714 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4716 int needs_hexify
= 0;
4718 if (outfile_autohex
== 1)
4720 for (uint i
= 0; i
< plain_len
; i
++)
4722 if (plain_ptr
[i
] < 0x20)
4729 if (plain_ptr
[i
] > 0x7f)
4738 if (needs_hexify
== 1)
4740 fprintf (fp
, "$HEX[");
4742 for (uint i
= 0; i
< plain_len
; i
++)
4744 fprintf (fp
, "%02x", plain_ptr
[i
]);
4751 fwrite (plain_ptr
, plain_len
, 1, fp
);
4755 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
)
4757 uint outfile_format
= data
.outfile_format
;
4759 char separator
= data
.separator
;
4761 if (outfile_format
& OUTFILE_FMT_HASH
)
4763 fprintf (out_fp
, "%s", out_buf
);
4765 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4767 fputc (separator
, out_fp
);
4770 else if (data
.username
)
4772 if (username
!= NULL
)
4774 for (uint i
= 0; i
< user_len
; i
++)
4776 fprintf (out_fp
, "%c", username
[i
]);
4779 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4781 fputc (separator
, out_fp
);
4786 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4788 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4790 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4792 fputc (separator
, out_fp
);
4796 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4798 for (uint i
= 0; i
< plain_len
; i
++)
4800 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4803 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4805 fputc (separator
, out_fp
);
4809 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4812 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4817 fprintf (out_fp
, "%lu", crackpos
);
4819 fprintf (out_fp
, "%llu", crackpos
);
4824 fputc ('\n', out_fp
);
4827 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
)
4831 pot_key
.hash
.salt
= hashes_buf
->salt
;
4832 pot_key
.hash
.digest
= hashes_buf
->digest
;
4834 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4840 input_buf
[input_len
] = 0;
4843 unsigned char *username
= NULL
;
4848 user_t
*user
= hashes_buf
->hash_info
->user
;
4852 username
= (unsigned char *) (user
->user_name
);
4854 user_len
= user
->user_len
;
4858 // do output the line
4859 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4863 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4864 #define LM_MASKED_PLAIN "[notfound]"
4866 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
)
4872 pot_left_key
.hash
.salt
= hash_left
->salt
;
4873 pot_left_key
.hash
.digest
= hash_left
->digest
;
4875 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4879 uint weak_hash_found
= 0;
4881 pot_t pot_right_key
;
4883 pot_right_key
.hash
.salt
= hash_right
->salt
;
4884 pot_right_key
.hash
.digest
= hash_right
->digest
;
4886 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4888 if (pot_right_ptr
== NULL
)
4890 // special case, if "weak hash"
4892 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4894 weak_hash_found
= 1;
4896 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4898 // in theory this is not needed, but we are paranoia:
4900 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4901 pot_right_ptr
->plain_len
= 0;
4905 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4907 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
4912 // at least one half was found:
4916 input_buf
[input_len
] = 0;
4920 unsigned char *username
= NULL
;
4925 user_t
*user
= hash_left
->hash_info
->user
;
4929 username
= (unsigned char *) (user
->user_name
);
4931 user_len
= user
->user_len
;
4935 // mask the part which was not found
4937 uint left_part_masked
= 0;
4938 uint right_part_masked
= 0;
4940 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4942 if (pot_left_ptr
== NULL
)
4944 left_part_masked
= 1;
4946 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4948 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4950 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4951 pot_left_ptr
->plain_len
= mask_plain_len
;
4954 if (pot_right_ptr
== NULL
)
4956 right_part_masked
= 1;
4958 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4960 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4962 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4963 pot_right_ptr
->plain_len
= mask_plain_len
;
4966 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4970 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4972 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4974 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4976 // do output the line
4978 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4980 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4982 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4983 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4986 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
)
4990 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4992 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4994 if (pot_ptr
== NULL
)
4998 input_buf
[input_len
] = 0;
5000 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5004 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
)
5010 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5012 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5016 pot_t pot_right_key
;
5018 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5020 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5022 uint weak_hash_found
= 0;
5024 if (pot_right_ptr
== NULL
)
5026 // special case, if "weak hash"
5028 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5030 weak_hash_found
= 1;
5032 // we just need that pot_right_ptr is not a NULL pointer
5034 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5040 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5045 // ... at least one part was not cracked
5049 input_buf
[input_len
] = 0;
5051 // only show the hash part which is still not cracked
5053 uint user_len
= input_len
- 32;
5055 char hash_output
[user_len
+ 33];
5057 memset (hash_output
, 0, sizeof (hash_output
));
5059 memcpy (hash_output
, input_buf
, input_len
);
5061 if (pot_left_ptr
!= NULL
)
5063 // only show right part (because left part was already found)
5065 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5067 hash_output
[user_len
+ 16] = 0;
5070 if (pot_right_ptr
!= NULL
)
5072 // only show left part (because right part was already found)
5074 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5076 hash_output
[user_len
+ 16] = 0;
5079 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5081 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5084 uint
devices_to_devicemask (char *gpu_devices
)
5086 uint gpu_devicemask
= 0;
5090 char *devices
= strdup (gpu_devices
);
5092 char *next
= strtok (devices
, ",");
5096 uint gpu_id
= atoi (next
);
5098 if (gpu_id
< 1 || gpu_id
> 8)
5100 log_error ("ERROR: invalid gpu_id %u specified", gpu_id
);
5105 gpu_devicemask
|= 1 << (gpu_id
- 1);
5107 } while ((next
= strtok (NULL
, ",")) != NULL
);
5112 return gpu_devicemask
;
5115 uint
get_random_num (uint min
, uint max
)
5117 if (min
== max
) return (min
);
5119 return (uint
) ((rand () % (max
- min
)) + min
);
5122 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5124 uint32_t quotient
= dividend
/ divisor
;
5126 if (dividend
% divisor
) quotient
++;
5131 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5133 uint64_t quotient
= dividend
/ divisor
;
5135 if (dividend
% divisor
) quotient
++;
5140 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5142 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5143 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5145 if (tm
->tm_year
- 70)
5147 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5148 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5150 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5152 else if (tm
->tm_yday
)
5154 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5155 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5157 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5159 else if (tm
->tm_hour
)
5161 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5162 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5164 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5166 else if (tm
->tm_min
)
5168 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5169 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5171 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5175 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5177 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5181 void format_speed_display (float val
, char *buf
, size_t len
)
5192 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5203 /* generate output */
5207 snprintf (buf
, len
- 1, "%.0f ", val
);
5211 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5215 void lowercase (char *buf
, int len
)
5217 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5220 void uppercase (char *buf
, int len
)
5222 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5225 int fgetl (FILE *fp
, char *line_buf
)
5231 const int c
= fgetc (fp
);
5233 if (c
== EOF
) break;
5235 line_buf
[line_len
] = (char) c
;
5239 if (line_len
== BUFSIZ
) line_len
--;
5241 if (c
== '\n') break;
5244 if (line_len
== 0) return 0;
5246 if (line_buf
[line_len
- 1] == '\n')
5250 line_buf
[line_len
] = 0;
5253 if (line_len
== 0) return 0;
5255 if (line_buf
[line_len
- 1] == '\r')
5259 line_buf
[line_len
] = 0;
5265 int in_superchop (char *buf
)
5267 int len
= strlen (buf
);
5271 if (buf
[len
- 1] == '\n')
5278 if (buf
[len
- 1] == '\r')
5293 char **scan_directory (const char *path
)
5295 char *tmp_path
= mystrdup (path
);
5297 size_t tmp_path_len
= strlen (tmp_path
);
5299 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5301 tmp_path
[tmp_path_len
- 1] = 0;
5303 tmp_path_len
= strlen (tmp_path
);
5306 char **files
= NULL
;
5312 if ((d
= opendir (tmp_path
)) != NULL
)
5316 while ((de
= readdir (d
)) != NULL
)
5318 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5320 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5322 char *path_file
= (char *) mymalloc (path_size
+ 1);
5324 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5326 path_file
[path_size
] = 0;
5330 if ((d_test
= opendir (path_file
)) != NULL
)
5338 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5342 files
[num_files
- 1] = path_file
;
5348 else if (errno
== ENOTDIR
)
5350 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5354 files
[num_files
- 1] = mystrdup (path
);
5357 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5361 files
[num_files
- 1] = NULL
;
5368 int count_dictionaries (char **dictionary_files
)
5370 if (dictionary_files
== NULL
) return 0;
5374 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5382 char *stroptitype (const uint opti_type
)
5386 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5387 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5388 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5389 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5390 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5391 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5392 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5393 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5394 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5395 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5396 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5397 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5398 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5399 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5405 char *strparser (const uint parser_status
)
5407 switch (parser_status
)
5409 case PARSER_OK
: return ((char *) PA_000
); break;
5410 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5411 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5412 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5413 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5414 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5415 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5416 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5417 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5418 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5419 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5420 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5421 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5422 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5423 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5424 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5425 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5428 return ((char *) PA_255
);
5431 char *strhashtype (const uint hash_mode
)
5435 case 0: return ((char *) HT_00000
); break;
5436 case 10: return ((char *) HT_00010
); break;
5437 case 11: return ((char *) HT_00011
); break;
5438 case 12: return ((char *) HT_00012
); break;
5439 case 20: return ((char *) HT_00020
); break;
5440 case 21: return ((char *) HT_00021
); break;
5441 case 22: return ((char *) HT_00022
); break;
5442 case 23: return ((char *) HT_00023
); break;
5443 case 30: return ((char *) HT_00030
); break;
5444 case 40: return ((char *) HT_00040
); break;
5445 case 50: return ((char *) HT_00050
); break;
5446 case 60: return ((char *) HT_00060
); break;
5447 case 100: return ((char *) HT_00100
); break;
5448 case 101: return ((char *) HT_00101
); break;
5449 case 110: return ((char *) HT_00110
); break;
5450 case 111: return ((char *) HT_00111
); break;
5451 case 112: return ((char *) HT_00112
); break;
5452 case 120: return ((char *) HT_00120
); break;
5453 case 121: return ((char *) HT_00121
); break;
5454 case 122: return ((char *) HT_00122
); break;
5455 case 124: return ((char *) HT_00124
); break;
5456 case 130: return ((char *) HT_00130
); break;
5457 case 131: return ((char *) HT_00131
); break;
5458 case 132: return ((char *) HT_00132
); break;
5459 case 133: return ((char *) HT_00133
); break;
5460 case 140: return ((char *) HT_00140
); break;
5461 case 141: return ((char *) HT_00141
); break;
5462 case 150: return ((char *) HT_00150
); break;
5463 case 160: return ((char *) HT_00160
); break;
5464 case 190: return ((char *) HT_00190
); break;
5465 case 200: return ((char *) HT_00200
); break;
5466 case 300: return ((char *) HT_00300
); break;
5467 case 400: return ((char *) HT_00400
); break;
5468 case 500: return ((char *) HT_00500
); break;
5469 case 501: return ((char *) HT_00501
); break;
5470 case 900: return ((char *) HT_00900
); break;
5471 case 910: return ((char *) HT_00910
); break;
5472 case 1000: return ((char *) HT_01000
); break;
5473 case 1100: return ((char *) HT_01100
); break;
5474 case 1400: return ((char *) HT_01400
); break;
5475 case 1410: return ((char *) HT_01410
); break;
5476 case 1420: return ((char *) HT_01420
); break;
5477 case 1421: return ((char *) HT_01421
); break;
5478 case 1430: return ((char *) HT_01430
); break;
5479 case 1440: return ((char *) HT_01440
); break;
5480 case 1441: return ((char *) HT_01441
); break;
5481 case 1450: return ((char *) HT_01450
); break;
5482 case 1460: return ((char *) HT_01460
); break;
5483 case 1500: return ((char *) HT_01500
); break;
5484 case 1600: return ((char *) HT_01600
); break;
5485 case 1700: return ((char *) HT_01700
); break;
5486 case 1710: return ((char *) HT_01710
); break;
5487 case 1711: return ((char *) HT_01711
); break;
5488 case 1720: return ((char *) HT_01720
); break;
5489 case 1722: return ((char *) HT_01722
); break;
5490 case 1730: return ((char *) HT_01730
); break;
5491 case 1731: return ((char *) HT_01731
); break;
5492 case 1740: return ((char *) HT_01740
); break;
5493 case 1750: return ((char *) HT_01750
); break;
5494 case 1760: return ((char *) HT_01760
); break;
5495 case 1800: return ((char *) HT_01800
); break;
5496 case 2100: return ((char *) HT_02100
); break;
5497 case 2400: return ((char *) HT_02400
); break;
5498 case 2410: return ((char *) HT_02410
); break;
5499 case 2500: return ((char *) HT_02500
); break;
5500 case 2600: return ((char *) HT_02600
); break;
5501 case 2611: return ((char *) HT_02611
); break;
5502 case 2612: return ((char *) HT_02612
); break;
5503 case 2711: return ((char *) HT_02711
); break;
5504 case 2811: return ((char *) HT_02811
); break;
5505 case 3000: return ((char *) HT_03000
); break;
5506 case 3100: return ((char *) HT_03100
); break;
5507 case 3200: return ((char *) HT_03200
); break;
5508 case 3710: return ((char *) HT_03710
); break;
5509 case 3711: return ((char *) HT_03711
); break;
5510 case 3800: return ((char *) HT_03800
); break;
5511 case 4300: return ((char *) HT_04300
); break;
5512 case 4400: return ((char *) HT_04400
); break;
5513 case 4500: return ((char *) HT_04500
); break;
5514 case 4700: return ((char *) HT_04700
); break;
5515 case 4800: return ((char *) HT_04800
); break;
5516 case 4900: return ((char *) HT_04900
); break;
5517 case 5000: return ((char *) HT_05000
); break;
5518 case 5100: return ((char *) HT_05100
); break;
5519 case 5200: return ((char *) HT_05200
); break;
5520 case 5300: return ((char *) HT_05300
); break;
5521 case 5400: return ((char *) HT_05400
); break;
5522 case 5500: return ((char *) HT_05500
); break;
5523 case 5600: return ((char *) HT_05600
); break;
5524 case 5700: return ((char *) HT_05700
); break;
5525 case 5800: return ((char *) HT_05800
); break;
5526 case 6000: return ((char *) HT_06000
); break;
5527 case 6100: return ((char *) HT_06100
); break;
5528 case 6211: return ((char *) HT_06211
); break;
5529 case 6212: return ((char *) HT_06212
); break;
5530 case 6213: return ((char *) HT_06213
); break;
5531 case 6221: return ((char *) HT_06221
); break;
5532 case 6222: return ((char *) HT_06222
); break;
5533 case 6223: return ((char *) HT_06223
); break;
5534 case 6231: return ((char *) HT_06231
); break;
5535 case 6232: return ((char *) HT_06232
); break;
5536 case 6233: return ((char *) HT_06233
); break;
5537 case 6241: return ((char *) HT_06241
); break;
5538 case 6242: return ((char *) HT_06242
); break;
5539 case 6243: return ((char *) HT_06243
); break;
5540 case 6300: return ((char *) HT_06300
); break;
5541 case 6400: return ((char *) HT_06400
); break;
5542 case 6500: return ((char *) HT_06500
); break;
5543 case 6600: return ((char *) HT_06600
); break;
5544 case 6700: return ((char *) HT_06700
); break;
5545 case 6800: return ((char *) HT_06800
); break;
5546 case 6900: return ((char *) HT_06900
); break;
5547 case 7100: return ((char *) HT_07100
); break;
5548 case 7200: return ((char *) HT_07200
); break;
5549 case 7300: return ((char *) HT_07300
); break;
5550 case 7400: return ((char *) HT_07400
); break;
5551 case 7500: return ((char *) HT_07500
); break;
5552 case 7600: return ((char *) HT_07600
); break;
5553 case 7700: return ((char *) HT_07700
); break;
5554 case 7800: return ((char *) HT_07800
); break;
5555 case 7900: return ((char *) HT_07900
); break;
5556 case 8000: return ((char *) HT_08000
); break;
5557 case 8100: return ((char *) HT_08100
); break;
5558 case 8200: return ((char *) HT_08200
); break;
5559 case 8300: return ((char *) HT_08300
); break;
5560 case 8400: return ((char *) HT_08400
); break;
5561 case 8500: return ((char *) HT_08500
); break;
5562 case 8600: return ((char *) HT_08600
); break;
5563 case 8700: return ((char *) HT_08700
); break;
5564 case 8800: return ((char *) HT_08800
); break;
5565 case 8900: return ((char *) HT_08900
); break;
5566 case 9000: return ((char *) HT_09000
); break;
5567 case 9100: return ((char *) HT_09100
); break;
5568 case 9200: return ((char *) HT_09200
); break;
5569 case 9300: return ((char *) HT_09300
); break;
5570 case 9400: return ((char *) HT_09400
); break;
5571 case 9500: return ((char *) HT_09500
); break;
5572 case 9600: return ((char *) HT_09600
); break;
5573 case 9700: return ((char *) HT_09700
); break;
5574 case 9710: return ((char *) HT_09710
); break;
5575 case 9720: return ((char *) HT_09720
); break;
5576 case 9800: return ((char *) HT_09800
); break;
5577 case 9810: return ((char *) HT_09810
); break;
5578 case 9820: return ((char *) HT_09820
); break;
5579 case 9900: return ((char *) HT_09900
); break;
5580 case 10000: return ((char *) HT_10000
); break;
5581 case 10100: return ((char *) HT_10100
); break;
5582 case 10200: return ((char *) HT_10200
); break;
5583 case 10300: return ((char *) HT_10300
); break;
5584 case 10400: return ((char *) HT_10400
); break;
5585 case 10410: return ((char *) HT_10410
); break;
5586 case 10420: return ((char *) HT_10420
); break;
5587 case 10500: return ((char *) HT_10500
); break;
5588 case 10600: return ((char *) HT_10600
); break;
5589 case 10700: return ((char *) HT_10700
); break;
5590 case 10800: return ((char *) HT_10800
); break;
5591 case 10900: return ((char *) HT_10900
); break;
5592 case 11000: return ((char *) HT_11000
); break;
5593 case 11100: return ((char *) HT_11100
); break;
5594 case 11200: return ((char *) HT_11200
); break;
5595 case 11300: return ((char *) HT_11300
); break;
5596 case 11400: return ((char *) HT_11400
); break;
5597 case 11500: return ((char *) HT_11500
); break;
5598 case 11600: return ((char *) HT_11600
); break;
5599 case 11700: return ((char *) HT_11700
); break;
5600 case 11800: return ((char *) HT_11800
); break;
5601 case 11900: return ((char *) HT_11900
); break;
5602 case 12000: return ((char *) HT_12000
); break;
5603 case 12100: return ((char *) HT_12100
); break;
5604 case 12200: return ((char *) HT_12200
); break;
5605 case 12300: return ((char *) HT_12300
); break;
5606 case 12400: return ((char *) HT_12400
); break;
5607 case 12500: return ((char *) HT_12500
); break;
5608 case 12600: return ((char *) HT_12600
); break;
5609 case 12700: return ((char *) HT_12700
); break;
5610 case 12800: return ((char *) HT_12800
); break;
5613 return ((char *) "Unknown");
5616 char *strstatus (const uint devices_status
)
5618 switch (devices_status
)
5620 case STATUS_INIT
: return ((char *) ST_0000
); break;
5621 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5622 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5623 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5624 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5625 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5626 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5627 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5628 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5629 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5632 return ((char *) "Unknown");
5635 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5637 uint hash_type
= data
.hash_type
;
5638 uint hash_mode
= data
.hash_mode
;
5639 uint salt_type
= data
.salt_type
;
5640 uint opts_type
= data
.opts_type
;
5641 uint opti_type
= data
.opti_type
;
5642 uint dgst_size
= data
.dgst_size
;
5644 char *hashfile
= data
.hashfile
;
5648 uint digest_buf
[64];
5650 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5652 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5654 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5656 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5662 case HASH_TYPE_DESCRYPT
:
5663 FP (digest_buf
[1], digest_buf
[0], tt
);
5666 case HASH_TYPE_DESRACF
:
5667 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5668 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5670 FP (digest_buf
[1], digest_buf
[0], tt
);
5674 FP (digest_buf
[1], digest_buf
[0], tt
);
5677 case HASH_TYPE_NETNTLM
:
5678 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5679 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5680 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5681 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5683 FP (digest_buf
[1], digest_buf
[0], tt
);
5684 FP (digest_buf
[3], digest_buf
[2], tt
);
5687 case HASH_TYPE_BSDICRYPT
:
5688 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5689 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5691 FP (digest_buf
[1], digest_buf
[0], tt
);
5696 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5701 digest_buf
[0] += MD4M_A
;
5702 digest_buf
[1] += MD4M_B
;
5703 digest_buf
[2] += MD4M_C
;
5704 digest_buf
[3] += MD4M_D
;
5708 digest_buf
[0] += MD5M_A
;
5709 digest_buf
[1] += MD5M_B
;
5710 digest_buf
[2] += MD5M_C
;
5711 digest_buf
[3] += MD5M_D
;
5714 case HASH_TYPE_SHA1
:
5715 digest_buf
[0] += SHA1M_A
;
5716 digest_buf
[1] += SHA1M_B
;
5717 digest_buf
[2] += SHA1M_C
;
5718 digest_buf
[3] += SHA1M_D
;
5719 digest_buf
[4] += SHA1M_E
;
5722 case HASH_TYPE_SHA256
:
5723 digest_buf
[0] += SHA256M_A
;
5724 digest_buf
[1] += SHA256M_B
;
5725 digest_buf
[2] += SHA256M_C
;
5726 digest_buf
[3] += SHA256M_D
;
5727 digest_buf
[4] += SHA256M_E
;
5728 digest_buf
[5] += SHA256M_F
;
5729 digest_buf
[6] += SHA256M_G
;
5730 digest_buf
[7] += SHA256M_H
;
5733 case HASH_TYPE_SHA384
:
5734 digest_buf64
[0] += SHA384M_A
;
5735 digest_buf64
[1] += SHA384M_B
;
5736 digest_buf64
[2] += SHA384M_C
;
5737 digest_buf64
[3] += SHA384M_D
;
5738 digest_buf64
[4] += SHA384M_E
;
5739 digest_buf64
[5] += SHA384M_F
;
5740 digest_buf64
[6] += 0;
5741 digest_buf64
[7] += 0;
5744 case HASH_TYPE_SHA512
:
5745 digest_buf64
[0] += SHA512M_A
;
5746 digest_buf64
[1] += SHA512M_B
;
5747 digest_buf64
[2] += SHA512M_C
;
5748 digest_buf64
[3] += SHA512M_D
;
5749 digest_buf64
[4] += SHA512M_E
;
5750 digest_buf64
[5] += SHA512M_F
;
5751 digest_buf64
[6] += SHA512M_G
;
5752 digest_buf64
[7] += SHA512M_H
;
5757 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5759 if (dgst_size
== DGST_SIZE_4_2
)
5761 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5763 else if (dgst_size
== DGST_SIZE_4_4
)
5765 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5767 else if (dgst_size
== DGST_SIZE_4_5
)
5769 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5771 else if (dgst_size
== DGST_SIZE_4_6
)
5773 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5775 else if (dgst_size
== DGST_SIZE_4_8
)
5777 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5779 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5781 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5783 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5785 else if (hash_type
== HASH_TYPE_SHA384
)
5787 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5789 else if (hash_type
== HASH_TYPE_SHA512
)
5791 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5793 else if (hash_type
== HASH_TYPE_GOST
)
5795 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5798 else if (dgst_size
== DGST_SIZE_4_64
)
5800 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5802 else if (dgst_size
== DGST_SIZE_8_25
)
5804 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5808 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5809 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5810 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5816 memset (&salt
, 0, sizeof (salt_t
));
5818 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5820 char *ptr
= (char *) salt
.salt_buf
;
5822 uint len
= salt
.salt_len
;
5824 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5830 case HASH_TYPE_NETNTLM
:
5832 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5833 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5835 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5841 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5843 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5851 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5853 uint max
= salt
.salt_len
/ 4;
5857 for (uint i
= 0; i
< max
; i
++)
5859 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5863 if (opts_type
& OPTS_TYPE_ST_HEX
)
5867 memset (tmp
, 0, sizeof (tmp
));
5869 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5871 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5876 memcpy (ptr
, tmp
, len
);
5879 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5881 memset (ptr
+ len
, 0, memset_size
);
5883 salt
.salt_len
= len
;
5887 // some modes require special encoding
5890 uint out_buf_plain
[256];
5891 uint out_buf_salt
[256];
5895 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5896 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5898 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5900 char *ptr_plain
= (char *) out_buf_plain
;
5901 char *ptr_salt
= (char *) out_buf_salt
;
5903 if (hash_mode
== 22)
5907 memset (username
, 0, sizeof (username
));
5909 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5911 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5913 uint16_t *ptr
= (uint16_t *) digest_buf
;
5915 tmp_buf
[ 0] = sig
[0];
5916 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5917 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5918 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5919 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5920 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5921 tmp_buf
[ 6] = sig
[1];
5922 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5923 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5924 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5925 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5926 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5927 tmp_buf
[12] = sig
[2];
5928 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5929 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5930 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5931 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5932 tmp_buf
[17] = sig
[3];
5933 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5934 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5935 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5936 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5937 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5938 tmp_buf
[23] = sig
[4];
5939 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5940 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5941 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5942 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5943 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5944 tmp_buf
[29] = sig
[5];
5946 snprintf (out_buf
, len
-1, "%s:%s",
5950 else if (hash_mode
== 23)
5952 // do not show the \nskyper\n part in output
5954 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5956 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5958 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5965 else if (hash_mode
== 101)
5967 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5969 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5970 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5971 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5972 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5973 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5975 memcpy (tmp_buf
, digest_buf
, 20);
5977 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5979 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5981 else if (hash_mode
== 111)
5983 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5985 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5986 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5987 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5988 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5989 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5991 memcpy (tmp_buf
, digest_buf
, 20);
5992 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5994 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5996 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
5998 else if (hash_mode
== 122)
6000 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6001 (unsigned char *) salt
.salt_buf
,
6008 else if (hash_mode
== 124)
6010 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6011 (unsigned char *) salt
.salt_buf
,
6018 else if (hash_mode
== 131)
6020 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6021 (unsigned char *) salt
.salt_buf
,
6029 else if (hash_mode
== 132)
6031 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6032 (unsigned char *) salt
.salt_buf
,
6039 else if (hash_mode
== 133)
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]);
6047 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6049 memcpy (tmp_buf
, digest_buf
, 20);
6051 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6053 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6055 else if (hash_mode
== 141)
6057 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6059 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6061 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6063 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6065 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6066 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6067 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6068 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6069 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6071 memcpy (tmp_buf
, digest_buf
, 20);
6073 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6077 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6079 else if (hash_mode
== 400)
6081 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6083 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6084 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6085 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6086 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6088 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6090 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6092 else if (hash_mode
== 500)
6094 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6096 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6097 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6098 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6099 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6101 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6103 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6105 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6109 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6112 else if (hash_mode
== 501)
6114 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6116 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6117 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6119 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6121 else if (hash_mode
== 1421)
6123 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6125 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6141 else if (hash_mode
== 1441)
6143 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6145 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6147 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6149 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6151 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6152 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6153 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6154 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6155 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6156 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6157 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6158 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6160 memcpy (tmp_buf
, digest_buf
, 32);
6162 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6166 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6168 else if (hash_mode
== 1500)
6170 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6171 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6172 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6173 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6174 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6176 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6178 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6180 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6181 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6183 memcpy (tmp_buf
, digest_buf
, 8);
6185 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6187 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6191 else if (hash_mode
== 1600)
6193 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6195 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6196 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6197 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6198 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6200 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6202 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6204 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6208 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6211 else if (hash_mode
== 1711)
6213 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6215 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6216 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6217 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6218 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6219 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6220 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6221 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6222 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6224 memcpy (tmp_buf
, digest_buf
, 64);
6225 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6227 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6229 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6231 else if (hash_mode
== 1722)
6233 uint
*ptr
= digest_buf
;
6235 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6236 (unsigned char *) salt
.salt_buf
,
6246 else if (hash_mode
== 1731)
6248 uint
*ptr
= digest_buf
;
6250 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6251 (unsigned char *) salt
.salt_buf
,
6261 else if (hash_mode
== 1800)
6265 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6266 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6267 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6268 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6269 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6270 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6271 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6272 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6274 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6276 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6278 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6282 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6285 else if (hash_mode
== 2100)
6289 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6291 salt
.salt_iter
+ 1);
6293 uint signature_len
= strlen (out_buf
);
6295 pos
+= signature_len
;
6296 len
-= signature_len
;
6298 char *salt_ptr
= (char *) salt
.salt_buf
;
6300 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6302 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6303 byte_swap_32 (digest_buf
[0]),
6304 byte_swap_32 (digest_buf
[1]),
6305 byte_swap_32 (digest_buf
[2]),
6306 byte_swap_32 (digest_buf
[3]));
6308 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6310 memcpy (tmp_buf
, digest_buf
, 16);
6312 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6314 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6315 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6316 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6317 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6319 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6320 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6321 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6322 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6324 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6325 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6326 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6327 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6329 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6330 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6331 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6332 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6334 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6335 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6336 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6337 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6341 else if (hash_mode
== 2500)
6343 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6345 wpa_t
*wpa
= &wpas
[salt_pos
];
6349 char *pke_ptr
= (char *) pke
;
6351 for (uint i
= 0; i
< 25; i
++)
6353 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6356 unsigned char mac1
[6];
6357 unsigned char mac2
[6];
6359 memcpy (mac1
, pke_ptr
+ 23, 6);
6360 memcpy (mac2
, pke_ptr
+ 29, 6);
6362 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6363 (char *) salt
.salt_buf
,
6377 else if (hash_mode
== 4400)
6379 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6380 byte_swap_32 (digest_buf
[0]),
6381 byte_swap_32 (digest_buf
[1]),
6382 byte_swap_32 (digest_buf
[2]),
6383 byte_swap_32 (digest_buf
[3]));
6385 else if (hash_mode
== 4700)
6387 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6388 byte_swap_32 (digest_buf
[0]),
6389 byte_swap_32 (digest_buf
[1]),
6390 byte_swap_32 (digest_buf
[2]),
6391 byte_swap_32 (digest_buf
[3]),
6392 byte_swap_32 (digest_buf
[4]));
6394 else if (hash_mode
== 4800)
6396 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6398 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6403 byte_swap_32 (salt
.salt_buf
[0]),
6404 byte_swap_32 (salt
.salt_buf
[1]),
6405 byte_swap_32 (salt
.salt_buf
[2]),
6406 byte_swap_32 (salt
.salt_buf
[3]),
6409 else if (hash_mode
== 4900)
6411 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6412 byte_swap_32 (digest_buf
[0]),
6413 byte_swap_32 (digest_buf
[1]),
6414 byte_swap_32 (digest_buf
[2]),
6415 byte_swap_32 (digest_buf
[3]),
6416 byte_swap_32 (digest_buf
[4]));
6418 else if (hash_mode
== 5100)
6420 snprintf (out_buf
, len
-1, "%08x%08x",
6424 else if (hash_mode
== 5200)
6426 snprintf (out_buf
, len
-1, "%s", hashfile
);
6428 else if (hash_mode
== 5300)
6430 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6432 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6434 int buf_len
= len
-1;
6438 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6440 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6442 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6444 snprintf (out_buf
, buf_len
, ":");
6450 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6458 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6460 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6462 if ((i
== 0) || (i
== 5))
6464 snprintf (out_buf
, buf_len
, ":");
6470 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6478 for (uint i
= 0; i
< 4; i
++)
6482 snprintf (out_buf
, buf_len
, ":");
6488 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6494 else if (hash_mode
== 5400)
6496 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6498 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6500 int buf_len
= len
-1;
6504 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6506 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6508 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6510 snprintf (out_buf
, buf_len
, ":");
6516 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6524 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6526 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6528 if ((i
== 0) || (i
== 5))
6530 snprintf (out_buf
, buf_len
, ":");
6536 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6544 for (uint i
= 0; i
< 5; i
++)
6548 snprintf (out_buf
, buf_len
, ":");
6554 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6560 else if (hash_mode
== 5500)
6562 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6564 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6567 char domain_buf
[64];
6568 char srvchall_buf
[1024];
6569 char clichall_buf
[1024];
6571 memset (user_buf
, 0, sizeof (user_buf
));
6572 memset (domain_buf
, 0, sizeof (domain_buf
));
6573 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6574 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6576 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6578 char *ptr
= (char *) netntlm
->userdomain_buf
;
6580 user_buf
[i
] = ptr
[j
];
6583 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6585 char *ptr
= (char *) netntlm
->userdomain_buf
;
6587 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6590 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6592 char *ptr
= (char *) netntlm
->chall_buf
;
6594 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6597 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6599 char *ptr
= (char *) netntlm
->chall_buf
;
6601 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6604 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6612 byte_swap_32 (salt
.salt_buf_pc
[0]),
6613 byte_swap_32 (salt
.salt_buf_pc
[1]),
6616 else if (hash_mode
== 5600)
6618 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6620 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6623 char domain_buf
[64];
6624 char srvchall_buf
[1024];
6625 char clichall_buf
[1024];
6627 memset (user_buf
, 0, sizeof (user_buf
));
6628 memset (domain_buf
, 0, sizeof (domain_buf
));
6629 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6630 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6632 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6634 char *ptr
= (char *) netntlm
->userdomain_buf
;
6636 user_buf
[i
] = ptr
[j
];
6639 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6641 char *ptr
= (char *) netntlm
->userdomain_buf
;
6643 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6646 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6648 char *ptr
= (char *) netntlm
->chall_buf
;
6650 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6653 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6655 char *ptr
= (char *) netntlm
->chall_buf
;
6657 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6660 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6670 else if (hash_mode
== 5700)
6672 // the encoder is a bit too 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]);
6678 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6679 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6680 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6681 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6683 memcpy (tmp_buf
, digest_buf
, 32);
6685 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6689 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6691 else if (hash_mode
== 5800)
6693 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6694 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6695 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6696 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6697 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6699 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6706 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6708 snprintf (out_buf
, len
-1, "%s", hashfile
);
6710 else if (hash_mode
== 6300)
6712 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6714 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6715 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6716 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6717 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6719 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6721 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6723 else if (hash_mode
== 6400)
6725 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6727 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6729 else if (hash_mode
== 6500)
6731 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6733 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6735 else if (hash_mode
== 6600)
6737 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6739 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6741 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6742 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6744 uint buf_len
= len
- 1;
6746 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6749 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6751 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6756 else if (hash_mode
== 6700)
6758 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6760 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6762 else if (hash_mode
== 6800)
6764 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6766 else if (hash_mode
== 7100)
6768 uint
*ptr
= digest_buf
;
6770 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6772 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6776 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6777 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6778 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6779 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6780 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6781 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6782 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6783 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6785 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",
6786 SIGNATURE_SHA512OSX
,
6788 esalt
[ 0], esalt
[ 1],
6789 esalt
[ 2], esalt
[ 3],
6790 esalt
[ 4], esalt
[ 5],
6791 esalt
[ 6], esalt
[ 7],
6799 ptr
[15], ptr
[14]);
6801 else if (hash_mode
== 7200)
6803 uint
*ptr
= digest_buf
;
6805 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6807 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6811 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6813 len_used
= strlen (out_buf
);
6815 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6817 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6819 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6822 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",
6830 ptr
[15], ptr
[14]);
6832 else if (hash_mode
== 7300)
6834 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6836 rakp_t
*rakp
= &rakps
[salt_pos
];
6838 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6840 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6843 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6850 else if (hash_mode
== 7400)
6852 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6854 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6855 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6856 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6857 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6858 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6859 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6860 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6861 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6863 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6865 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6867 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6871 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6874 else if (hash_mode
== 7500)
6876 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6878 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6880 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6881 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6885 char *ptr_data
= data
;
6887 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6889 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6892 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6894 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6899 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6901 (char *) krb5pa
->user
,
6902 (char *) krb5pa
->realm
,
6903 (char *) krb5pa
->salt
,
6906 else if (hash_mode
== 7700)
6908 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6909 (char *) salt
.salt_buf
,
6913 else if (hash_mode
== 7800)
6915 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6916 (char *) salt
.salt_buf
,
6923 else if (hash_mode
== 7900)
6925 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6929 char *tmp
= (char *) salt
.salt_buf_pc
;
6931 ptr_plain
[42] = tmp
[0];
6937 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6939 else if (hash_mode
== 8000)
6941 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6942 (unsigned char *) salt
.salt_buf
,
6952 else if (hash_mode
== 8100)
6954 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6955 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6957 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6958 (unsigned char *) salt
.salt_buf
,
6965 else if (hash_mode
== 8200)
6967 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6969 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6971 char data_buf
[4096];
6973 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6975 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6978 data_buf
[cloudkey
->data_len
* 2] = 0;
6980 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6981 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6982 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6983 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6984 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6985 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6986 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6987 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6989 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6990 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6991 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6992 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6994 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7010 else if (hash_mode
== 8300)
7014 char digest_buf_c
[33];
7016 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
7018 digest_buf_c
[32] = 0;
7022 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7024 char domain_buf_c
[33];
7026 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7028 for (uint i
= 0; i
< salt_pc_len
; i
++)
7030 const char next
= domain_buf_c
[i
];
7032 domain_buf_c
[i
] = '.';
7037 domain_buf_c
[salt_pc_len
] = 0;
7041 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7043 else if (hash_mode
== 8500)
7045 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7047 else if (hash_mode
== 2612)
7049 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7051 (char *) salt
.salt_buf
,
7057 else if (hash_mode
== 3711)
7059 char *salt_ptr
= (char *) salt
.salt_buf
;
7061 salt_ptr
[salt
.salt_len
- 1] = 0;
7063 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7064 SIGNATURE_MEDIAWIKI_B
,
7071 else if (hash_mode
== 8800)
7073 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7075 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7079 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7081 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7086 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7087 SIGNATURE_ANDROIDFDE
,
7088 byte_swap_32 (salt
.salt_buf
[0]),
7089 byte_swap_32 (salt
.salt_buf
[1]),
7090 byte_swap_32 (salt
.salt_buf
[2]),
7091 byte_swap_32 (salt
.salt_buf
[3]),
7092 byte_swap_32 (digest_buf
[0]),
7093 byte_swap_32 (digest_buf
[1]),
7094 byte_swap_32 (digest_buf
[2]),
7095 byte_swap_32 (digest_buf
[3]),
7098 else if (hash_mode
== 8900)
7100 uint N
= salt
.scrypt_N
;
7101 uint r
= salt
.scrypt_r
;
7102 uint p
= salt
.scrypt_p
;
7104 char base64_salt
[32];
7106 memset (base64_salt
, 0, 32);
7108 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7110 memset (tmp_buf
, 0, 46);
7112 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7113 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7114 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7115 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7116 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7117 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7118 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7119 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7120 digest_buf
[8] = 0; // needed for base64_encode ()
7122 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7124 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7132 else if (hash_mode
== 9000)
7134 snprintf (out_buf
, len
-1, "%s", hashfile
);
7136 else if (hash_mode
== 9200)
7140 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7142 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7144 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7148 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7149 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7150 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7151 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7152 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7153 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7154 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7155 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7156 digest_buf
[8] = 0; // needed for base64_encode ()
7159 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7161 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7162 tmp_buf
[43] = 0; // cut it here
7166 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7168 else if (hash_mode
== 9300)
7170 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7171 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7172 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7173 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7174 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7175 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7176 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7177 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7178 digest_buf
[8] = 0; // needed for base64_encode ()
7181 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7183 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7184 tmp_buf
[43] = 0; // cut it here
7186 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7188 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7190 else if (hash_mode
== 9400)
7192 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7194 office2007_t
*office2007
= &office2007s
[salt_pos
];
7196 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7197 SIGNATURE_OFFICE2007
,
7200 office2007
->keySize
,
7206 office2007
->encryptedVerifier
[0],
7207 office2007
->encryptedVerifier
[1],
7208 office2007
->encryptedVerifier
[2],
7209 office2007
->encryptedVerifier
[3],
7210 office2007
->encryptedVerifierHash
[0],
7211 office2007
->encryptedVerifierHash
[1],
7212 office2007
->encryptedVerifierHash
[2],
7213 office2007
->encryptedVerifierHash
[3],
7214 office2007
->encryptedVerifierHash
[4]);
7216 else if (hash_mode
== 9500)
7218 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7220 office2010_t
*office2010
= &office2010s
[salt_pos
];
7222 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,
7228 office2010
->encryptedVerifier
[0],
7229 office2010
->encryptedVerifier
[1],
7230 office2010
->encryptedVerifier
[2],
7231 office2010
->encryptedVerifier
[3],
7232 office2010
->encryptedVerifierHash
[0],
7233 office2010
->encryptedVerifierHash
[1],
7234 office2010
->encryptedVerifierHash
[2],
7235 office2010
->encryptedVerifierHash
[3],
7236 office2010
->encryptedVerifierHash
[4],
7237 office2010
->encryptedVerifierHash
[5],
7238 office2010
->encryptedVerifierHash
[6],
7239 office2010
->encryptedVerifierHash
[7]);
7241 else if (hash_mode
== 9600)
7243 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7245 office2013_t
*office2013
= &office2013s
[salt_pos
];
7247 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,
7253 office2013
->encryptedVerifier
[0],
7254 office2013
->encryptedVerifier
[1],
7255 office2013
->encryptedVerifier
[2],
7256 office2013
->encryptedVerifier
[3],
7257 office2013
->encryptedVerifierHash
[0],
7258 office2013
->encryptedVerifierHash
[1],
7259 office2013
->encryptedVerifierHash
[2],
7260 office2013
->encryptedVerifierHash
[3],
7261 office2013
->encryptedVerifierHash
[4],
7262 office2013
->encryptedVerifierHash
[5],
7263 office2013
->encryptedVerifierHash
[6],
7264 office2013
->encryptedVerifierHash
[7]);
7266 else if (hash_mode
== 9700)
7268 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7270 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7272 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7273 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7274 byte_swap_32 (salt
.salt_buf
[0]),
7275 byte_swap_32 (salt
.salt_buf
[1]),
7276 byte_swap_32 (salt
.salt_buf
[2]),
7277 byte_swap_32 (salt
.salt_buf
[3]),
7278 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7279 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7280 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7281 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7282 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7283 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7284 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7285 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7287 else if (hash_mode
== 9710)
7289 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7291 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7293 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7294 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7295 byte_swap_32 (salt
.salt_buf
[0]),
7296 byte_swap_32 (salt
.salt_buf
[1]),
7297 byte_swap_32 (salt
.salt_buf
[2]),
7298 byte_swap_32 (salt
.salt_buf
[3]),
7299 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7300 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7301 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7302 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7303 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7304 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7305 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7306 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7308 else if (hash_mode
== 9720)
7310 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7312 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7314 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7316 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7317 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7318 byte_swap_32 (salt
.salt_buf
[0]),
7319 byte_swap_32 (salt
.salt_buf
[1]),
7320 byte_swap_32 (salt
.salt_buf
[2]),
7321 byte_swap_32 (salt
.salt_buf
[3]),
7322 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7323 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7324 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7325 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7326 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7327 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7328 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7329 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7336 else if (hash_mode
== 9800)
7338 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7340 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7342 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7343 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7348 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7349 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7350 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7351 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7352 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7353 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7354 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7355 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7356 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7358 else if (hash_mode
== 9810)
7360 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7362 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7364 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7365 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7370 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7371 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7372 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7373 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7374 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7375 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7376 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7377 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7378 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7380 else if (hash_mode
== 9820)
7382 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7384 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7386 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7388 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7389 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7394 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7395 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7396 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7397 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7398 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7399 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7400 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7401 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7402 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7409 else if (hash_mode
== 10000)
7413 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7415 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7417 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7421 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7422 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7423 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7424 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7425 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7426 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7427 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7428 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7429 digest_buf
[8] = 0; // needed for base64_encode ()
7432 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7434 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7438 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7440 else if (hash_mode
== 10100)
7442 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7447 byte_swap_32 (salt
.salt_buf
[0]),
7448 byte_swap_32 (salt
.salt_buf
[1]),
7449 byte_swap_32 (salt
.salt_buf
[2]),
7450 byte_swap_32 (salt
.salt_buf
[3]));
7452 else if (hash_mode
== 10200)
7454 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7456 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7460 char challenge
[100];
7462 memset (challenge
, 0, sizeof (challenge
));
7464 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7470 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7471 (char *) cram_md5
->user
,
7479 memset (response
, 0, sizeof (response
));
7481 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7483 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7485 else if (hash_mode
== 10300)
7489 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7491 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7492 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7494 uint tmp_len
= 20 + salt
.salt_len
;
7498 char base64_encoded
[100];
7500 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7502 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7504 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7506 else if (hash_mode
== 10400)
7508 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7510 pdf_t
*pdf
= &pdfs
[salt_pos
];
7512 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",
7520 byte_swap_32 (pdf
->id_buf
[0]),
7521 byte_swap_32 (pdf
->id_buf
[1]),
7522 byte_swap_32 (pdf
->id_buf
[2]),
7523 byte_swap_32 (pdf
->id_buf
[3]),
7525 byte_swap_32 (pdf
->u_buf
[0]),
7526 byte_swap_32 (pdf
->u_buf
[1]),
7527 byte_swap_32 (pdf
->u_buf
[2]),
7528 byte_swap_32 (pdf
->u_buf
[3]),
7529 byte_swap_32 (pdf
->u_buf
[4]),
7530 byte_swap_32 (pdf
->u_buf
[5]),
7531 byte_swap_32 (pdf
->u_buf
[6]),
7532 byte_swap_32 (pdf
->u_buf
[7]),
7534 byte_swap_32 (pdf
->o_buf
[0]),
7535 byte_swap_32 (pdf
->o_buf
[1]),
7536 byte_swap_32 (pdf
->o_buf
[2]),
7537 byte_swap_32 (pdf
->o_buf
[3]),
7538 byte_swap_32 (pdf
->o_buf
[4]),
7539 byte_swap_32 (pdf
->o_buf
[5]),
7540 byte_swap_32 (pdf
->o_buf
[6]),
7541 byte_swap_32 (pdf
->o_buf
[7])
7544 else if (hash_mode
== 10410)
7546 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7548 pdf_t
*pdf
= &pdfs
[salt_pos
];
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",
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])
7582 else if (hash_mode
== 10420)
7584 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7586 pdf_t
*pdf
= &pdfs
[salt_pos
];
7588 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7590 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",
7598 byte_swap_32 (pdf
->id_buf
[0]),
7599 byte_swap_32 (pdf
->id_buf
[1]),
7600 byte_swap_32 (pdf
->id_buf
[2]),
7601 byte_swap_32 (pdf
->id_buf
[3]),
7603 byte_swap_32 (pdf
->u_buf
[0]),
7604 byte_swap_32 (pdf
->u_buf
[1]),
7605 byte_swap_32 (pdf
->u_buf
[2]),
7606 byte_swap_32 (pdf
->u_buf
[3]),
7607 byte_swap_32 (pdf
->u_buf
[4]),
7608 byte_swap_32 (pdf
->u_buf
[5]),
7609 byte_swap_32 (pdf
->u_buf
[6]),
7610 byte_swap_32 (pdf
->u_buf
[7]),
7612 byte_swap_32 (pdf
->o_buf
[0]),
7613 byte_swap_32 (pdf
->o_buf
[1]),
7614 byte_swap_32 (pdf
->o_buf
[2]),
7615 byte_swap_32 (pdf
->o_buf
[3]),
7616 byte_swap_32 (pdf
->o_buf
[4]),
7617 byte_swap_32 (pdf
->o_buf
[5]),
7618 byte_swap_32 (pdf
->o_buf
[6]),
7619 byte_swap_32 (pdf
->o_buf
[7]),
7627 else if (hash_mode
== 10500)
7629 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7631 pdf_t
*pdf
= &pdfs
[salt_pos
];
7633 if (pdf
->id_len
== 32)
7635 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",
7643 byte_swap_32 (pdf
->id_buf
[0]),
7644 byte_swap_32 (pdf
->id_buf
[1]),
7645 byte_swap_32 (pdf
->id_buf
[2]),
7646 byte_swap_32 (pdf
->id_buf
[3]),
7647 byte_swap_32 (pdf
->id_buf
[4]),
7648 byte_swap_32 (pdf
->id_buf
[5]),
7649 byte_swap_32 (pdf
->id_buf
[6]),
7650 byte_swap_32 (pdf
->id_buf
[7]),
7652 byte_swap_32 (pdf
->u_buf
[0]),
7653 byte_swap_32 (pdf
->u_buf
[1]),
7654 byte_swap_32 (pdf
->u_buf
[2]),
7655 byte_swap_32 (pdf
->u_buf
[3]),
7656 byte_swap_32 (pdf
->u_buf
[4]),
7657 byte_swap_32 (pdf
->u_buf
[5]),
7658 byte_swap_32 (pdf
->u_buf
[6]),
7659 byte_swap_32 (pdf
->u_buf
[7]),
7661 byte_swap_32 (pdf
->o_buf
[0]),
7662 byte_swap_32 (pdf
->o_buf
[1]),
7663 byte_swap_32 (pdf
->o_buf
[2]),
7664 byte_swap_32 (pdf
->o_buf
[3]),
7665 byte_swap_32 (pdf
->o_buf
[4]),
7666 byte_swap_32 (pdf
->o_buf
[5]),
7667 byte_swap_32 (pdf
->o_buf
[6]),
7668 byte_swap_32 (pdf
->o_buf
[7])
7673 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",
7681 byte_swap_32 (pdf
->id_buf
[0]),
7682 byte_swap_32 (pdf
->id_buf
[1]),
7683 byte_swap_32 (pdf
->id_buf
[2]),
7684 byte_swap_32 (pdf
->id_buf
[3]),
7686 byte_swap_32 (pdf
->u_buf
[0]),
7687 byte_swap_32 (pdf
->u_buf
[1]),
7688 byte_swap_32 (pdf
->u_buf
[2]),
7689 byte_swap_32 (pdf
->u_buf
[3]),
7690 byte_swap_32 (pdf
->u_buf
[4]),
7691 byte_swap_32 (pdf
->u_buf
[5]),
7692 byte_swap_32 (pdf
->u_buf
[6]),
7693 byte_swap_32 (pdf
->u_buf
[7]),
7695 byte_swap_32 (pdf
->o_buf
[0]),
7696 byte_swap_32 (pdf
->o_buf
[1]),
7697 byte_swap_32 (pdf
->o_buf
[2]),
7698 byte_swap_32 (pdf
->o_buf
[3]),
7699 byte_swap_32 (pdf
->o_buf
[4]),
7700 byte_swap_32 (pdf
->o_buf
[5]),
7701 byte_swap_32 (pdf
->o_buf
[6]),
7702 byte_swap_32 (pdf
->o_buf
[7])
7706 else if (hash_mode
== 10600)
7708 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7710 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7711 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7713 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7715 else if (hash_mode
== 10700)
7717 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7719 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7720 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7722 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7724 else if (hash_mode
== 10900)
7726 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7728 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7729 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7731 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7733 else if (hash_mode
== 11100)
7735 uint32_t salt_challenge
= salt
.salt_buf
[0];
7737 salt_challenge
= byte_swap_32 (salt_challenge
);
7739 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7741 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7742 SIGNATURE_POSTGRESQL_AUTH
,
7750 else if (hash_mode
== 11200)
7752 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7753 SIGNATURE_MYSQL_AUTH
,
7754 (unsigned char *) salt
.salt_buf
,
7761 else if (hash_mode
== 11300)
7763 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7765 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7767 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7768 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7769 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7771 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7772 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7773 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7775 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7777 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7779 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7782 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7784 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7786 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7789 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7791 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7793 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7796 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7797 SIGNATURE_BITCOIN_WALLET
,
7801 (unsigned char *) salt
.salt_buf
,
7809 free (cry_master_buf
);
7811 free (public_key_buf
);
7813 else if (hash_mode
== 11400)
7815 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7817 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7818 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7820 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7822 else if (hash_mode
== 11600)
7824 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7826 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7828 const uint data_len
= seven_zip
->data_len
;
7830 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7832 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7834 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7836 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7839 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7840 SIGNATURE_SEVEN_ZIP
,
7844 (char *) seven_zip
->salt_buf
,
7846 seven_zip
->iv_buf
[0],
7847 seven_zip
->iv_buf
[1],
7848 seven_zip
->iv_buf
[2],
7849 seven_zip
->iv_buf
[3],
7851 seven_zip
->data_len
,
7852 seven_zip
->unpack_size
,
7857 else if (hash_mode
== 11700)
7859 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7869 else if (hash_mode
== 11800)
7871 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7889 else if (hash_mode
== 11900)
7891 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7893 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7894 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7896 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7898 else if (hash_mode
== 12000)
7900 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7902 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7903 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7905 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7907 else if (hash_mode
== 12100)
7909 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7911 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7912 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7914 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7916 else if (hash_mode
== 12200)
7918 uint
*ptr_digest
= digest_buf
;
7919 uint
*ptr_salt
= salt
.salt_buf
;
7921 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7928 else if (hash_mode
== 12300)
7930 uint
*ptr_digest
= digest_buf
;
7931 uint
*ptr_salt
= salt
.salt_buf
;
7933 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",
7934 ptr_digest
[ 0], ptr_digest
[ 1],
7935 ptr_digest
[ 2], ptr_digest
[ 3],
7936 ptr_digest
[ 4], ptr_digest
[ 5],
7937 ptr_digest
[ 6], ptr_digest
[ 7],
7938 ptr_digest
[ 8], ptr_digest
[ 9],
7939 ptr_digest
[10], ptr_digest
[11],
7940 ptr_digest
[12], ptr_digest
[13],
7941 ptr_digest
[14], ptr_digest
[15],
7947 else if (hash_mode
== 12400)
7949 // encode iteration count
7953 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7954 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7955 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7956 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7961 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7962 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7963 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7964 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7969 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7971 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7972 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7974 memcpy (tmp_buf
, digest_buf
, 8);
7976 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7980 // fill the resulting buffer
7982 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7984 else if (hash_mode
== 12500)
7986 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7988 byte_swap_32 (salt
.salt_buf
[0]),
7989 byte_swap_32 (salt
.salt_buf
[1]),
7995 else if (hash_mode
== 12600)
7997 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7998 digest_buf
[0] + salt
.salt_buf_pc
[0],
7999 digest_buf
[1] + salt
.salt_buf_pc
[1],
8000 digest_buf
[2] + salt
.salt_buf_pc
[2],
8001 digest_buf
[3] + salt
.salt_buf_pc
[3],
8002 digest_buf
[4] + salt
.salt_buf_pc
[4],
8003 digest_buf
[5] + salt
.salt_buf_pc
[5],
8004 digest_buf
[6] + salt
.salt_buf_pc
[6],
8005 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8007 else if (hash_mode
== 12700)
8009 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8011 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8012 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8014 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8016 else if (hash_mode
== 12800)
8018 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
8020 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",
8033 byte_swap_32 (digest_buf
[0]),
8034 byte_swap_32 (digest_buf
[1]),
8035 byte_swap_32 (digest_buf
[2]),
8036 byte_swap_32 (digest_buf
[3]),
8037 byte_swap_32 (digest_buf
[4]),
8038 byte_swap_32 (digest_buf
[5]),
8039 byte_swap_32 (digest_buf
[6]),
8040 byte_swap_32 (digest_buf
[7])
8045 if (hash_type
== HASH_TYPE_MD4
)
8047 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8053 else if (hash_type
== HASH_TYPE_MD5
)
8055 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8061 else if (hash_type
== HASH_TYPE_SHA1
)
8063 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8070 else if (hash_type
== HASH_TYPE_SHA256
)
8072 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8082 else if (hash_type
== HASH_TYPE_SHA384
)
8084 uint
*ptr
= digest_buf
;
8086 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8094 else if (hash_type
== HASH_TYPE_SHA512
)
8096 uint
*ptr
= digest_buf
;
8098 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8108 else if (hash_type
== HASH_TYPE_LM
)
8110 snprintf (out_buf
, len
-1, "%08x%08x",
8114 else if (hash_type
== HASH_TYPE_ORACLEH
)
8116 snprintf (out_buf
, len
-1, "%08X%08X",
8120 else if (hash_type
== HASH_TYPE_BCRYPT
)
8122 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8123 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8125 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8127 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8129 else if (hash_type
== HASH_TYPE_KECCAK
)
8131 uint
*ptr
= digest_buf
;
8133 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",
8161 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8163 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8165 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8172 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8174 digest_buf
[ 0] = digest_buf
[ 0];
8175 digest_buf
[ 1] = digest_buf
[ 1];
8176 digest_buf
[ 2] = digest_buf
[ 2];
8177 digest_buf
[ 3] = digest_buf
[ 3];
8178 digest_buf
[ 4] = digest_buf
[ 4];
8179 digest_buf
[ 5] = digest_buf
[ 5];
8180 digest_buf
[ 6] = digest_buf
[ 6];
8181 digest_buf
[ 7] = digest_buf
[ 7];
8182 digest_buf
[ 8] = digest_buf
[ 8];
8183 digest_buf
[ 9] = digest_buf
[ 9];
8184 digest_buf
[10] = digest_buf
[10];
8185 digest_buf
[11] = digest_buf
[11];
8186 digest_buf
[12] = digest_buf
[12];
8187 digest_buf
[13] = digest_buf
[13];
8188 digest_buf
[14] = digest_buf
[14];
8189 digest_buf
[15] = digest_buf
[15];
8191 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8209 else if (hash_type
== HASH_TYPE_GOST
)
8211 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8221 else if (hash_type
== HASH_TYPE_MYSQL
)
8223 snprintf (out_buf
, len
-1, "%08x%08x",
8227 else if (hash_type
== HASH_TYPE_LOTUS5
)
8229 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8235 else if (hash_type
== HASH_TYPE_LOTUS6
)
8237 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8238 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8239 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8240 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8244 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8245 memcpy (buf
+ 5, digest_buf
, 9);
8249 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8251 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8254 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8256 else if (hash_type
== HASH_TYPE_LOTUS8
)
8260 memset (buf
, 0, sizeof (buf
));
8264 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8270 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8274 buf
[26] = salt
.salt_buf_pc
[0];
8275 buf
[27] = salt
.salt_buf_pc
[1];
8279 memcpy (buf
+ 28, digest_buf
, 8);
8281 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8285 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8287 else if (hash_type
== HASH_TYPE_CRC32
)
8289 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8293 if (salt_type
== SALT_TYPE_INTERN
)
8295 size_t pos
= strlen (out_buf
);
8297 out_buf
[pos
] = data
.separator
;
8299 char *ptr
= (char *) salt
.salt_buf
;
8301 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8303 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8307 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8309 memset (hccap
, 0, sizeof (hccap_t
));
8311 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8313 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8315 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8316 wpa_t
*wpa
= &wpas
[salt_pos
];
8318 hccap
->keyver
= wpa
->keyver
;
8320 hccap
->eapol_size
= wpa
->eapol_size
;
8322 if (wpa
->keyver
!= 1)
8326 for (uint i
= 0; i
< 64; i
++)
8328 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8331 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8335 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8340 for (int i
= 5; i
< 25; i
++)
8342 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8345 char *pke_ptr
= (char *) pke_tmp
;
8347 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8348 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8349 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8350 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8352 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8354 uint dgst_size
= data
.dgst_size
;
8356 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8358 if (wpa
->keyver
!= 1)
8362 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8363 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8364 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8365 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8367 memcpy (hccap
->keymic
, digest_tmp
, 16);
8371 memcpy (hccap
->keymic
, digest_ptr
, 16);
8375 void SuspendThreads ()
8377 if (data
.devices_status
== STATUS_RUNNING
)
8379 hc_timer_set (&data
.timer_paused
);
8381 data
.devices_status
= STATUS_PAUSED
;
8383 log_info ("Paused");
8387 void ResumeThreads ()
8389 if (data
.devices_status
== STATUS_PAUSED
)
8393 hc_timer_get (data
.timer_paused
, ms_paused
);
8395 data
.ms_paused
+= ms_paused
;
8397 data
.devices_status
= STATUS_RUNNING
;
8399 log_info ("Resumed");
8405 if (data
.devices_status
!= STATUS_RUNNING
) return;
8407 data
.devices_status
= STATUS_BYPASS
;
8409 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8412 void stop_at_checkpoint ()
8414 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8416 if (data
.devices_status
!= STATUS_RUNNING
) return;
8419 // this feature only makes sense if --restore-disable was not specified
8421 if (data
.restore_disable
== 1)
8423 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8428 // check if monitoring of Restore Point updates should be enabled or disabled
8430 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8432 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8434 // save the current restore point value
8436 data
.checkpoint_cur_words
= get_lowest_words_done ();
8438 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8442 data
.devices_status
= STATUS_RUNNING
;
8444 // reset the global value for checkpoint checks
8446 data
.checkpoint_cur_words
= 0;
8448 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8454 if (data
.devices_status
== STATUS_INIT
) return;
8455 if (data
.devices_status
== STATUS_STARTING
) return;
8457 data
.devices_status
= STATUS_ABORTED
;
8462 if (data
.devices_status
== STATUS_INIT
) return;
8463 if (data
.devices_status
== STATUS_STARTING
) return;
8465 data
.devices_status
= STATUS_QUIT
;
8468 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8472 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8476 memset (&st
, 0, sizeof (st
));
8478 stat (kernel_file
, &st
);
8480 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8482 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8484 if (num_read
!= (size_t) st
.st_size
)
8486 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8493 buf
[st
.st_size
] = 0;
8495 for (int i
= 0; i
< num_devices
; i
++)
8497 kernel_lengths
[i
] = (size_t) st
.st_size
;
8499 kernel_sources
[i
] = buf
;
8504 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8512 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8514 FILE *fp
= fopen (dst
, "wb");
8516 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8526 restore_data_t
*init_restore (int argc
, char **argv
)
8528 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8530 if (data
.restore_disable
== 0)
8532 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8536 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8540 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8549 char pidbin
[BUFSIZ
];
8554 memset (pidbin
, 0, sizeof (pidbin
));
8556 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8558 FILE *fd
= fopen (pidbin
, "rb");
8562 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8564 pidbin
[pidbin_len
] = 0;
8568 char *argv0_r
= strrchr (argv
[0], '/');
8570 char *pidbin_r
= strrchr (pidbin
, '/');
8572 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8574 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8576 if (strcmp (argv0_r
, pidbin_r
) == 0)
8578 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8585 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8587 char pidbin2
[BUFSIZ
];
8591 memset (pidbin2
, 0, sizeof (pidbin2
));
8593 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8594 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8596 pidbin
[pidbin_len
] = 0;
8597 pidbin2
[pidbin2_len
] = 0;
8601 if (strcmp (pidbin
, pidbin2
) == 0)
8603 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8611 if (rd
->version_bin
< RESTORE_MIN
)
8613 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8620 memset (rd
, 0, sizeof (restore_data_t
));
8622 rd
->version_bin
= VERSION_BIN
;
8625 rd
->pid
= getpid ();
8627 rd
->pid
= GetCurrentProcessId ();
8630 if (getcwd (rd
->cwd
, 255) == NULL
)
8643 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8645 FILE *fp
= fopen (eff_restore_file
, "rb");
8649 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8654 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8656 log_error ("ERROR: cannot read %s", eff_restore_file
);
8661 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8663 for (uint i
= 0; i
< rd
->argc
; i
++)
8667 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8669 log_error ("ERROR: cannot read %s", eff_restore_file
);
8674 size_t len
= strlen (buf
);
8676 if (len
) buf
[len
- 1] = 0;
8678 rd
->argv
[i
] = mystrdup (buf
);
8685 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8689 log_error ("Restore file is corrupted");
8692 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8694 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8696 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8701 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8705 if (chdir (rd
->cwd
))
8707 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8713 uint64_t get_lowest_words_done ()
8715 uint64_t words_cur
= -1;
8717 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8719 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8721 const uint64_t words_done
= device_param
->words_done
;
8723 if (words_done
< words_cur
) words_cur
= words_done
;
8726 // It's possible that a GPU's workload isn't finished right after a restore-case.
8727 // In that case, this function would return 0 and overwrite the real restore point
8728 // There's also data.words_cur which is set to rd->words_cur but it changes while
8729 // the attack is running therefore we should stick to rd->words_cur.
8730 // Note that -s influences rd->words_cur we should keep a close look on that.
8732 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8737 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8739 uint64_t words_cur
= get_lowest_words_done ();
8741 rd
->words_cur
= words_cur
;
8743 FILE *fp
= fopen (new_restore_file
, "wb");
8747 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8752 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8754 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8759 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8761 for (uint i
= 0; i
< rd
->argc
; i
++)
8763 fprintf (fp
, "%s", rd
->argv
[i
]);
8769 fsync (fileno (fp
));
8774 void cycle_restore ()
8776 const char *eff_restore_file
= data
.eff_restore_file
;
8777 const char *new_restore_file
= data
.new_restore_file
;
8779 restore_data_t
*rd
= data
.rd
;
8781 write_restore (new_restore_file
, rd
);
8785 memset (&st
, 0, sizeof(st
));
8787 if (stat (eff_restore_file
, &st
) == 0)
8789 if (unlink (eff_restore_file
))
8791 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8795 if (rename (new_restore_file
, eff_restore_file
))
8797 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8801 void check_checkpoint ()
8803 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8805 uint64_t words_cur
= get_lowest_words_done ();
8807 if (words_cur
!= data
.checkpoint_cur_words
)
8817 uint
set_gpu_accel (uint hash_mode
)
8821 case 0: return GET_ACCEL (0);
8822 case 10: return GET_ACCEL (10);
8823 case 11: return GET_ACCEL (11);
8824 case 12: return GET_ACCEL (12);
8825 case 20: return GET_ACCEL (20);
8826 case 21: return GET_ACCEL (21);
8827 case 22: return GET_ACCEL (22);
8828 case 23: return GET_ACCEL (23);
8829 case 30: return GET_ACCEL (30);
8830 case 40: return GET_ACCEL (40);
8831 case 50: return GET_ACCEL (50);
8832 case 60: return GET_ACCEL (60);
8833 case 100: return GET_ACCEL (100);
8834 case 101: return GET_ACCEL (101);
8835 case 110: return GET_ACCEL (110);
8836 case 111: return GET_ACCEL (111);
8837 case 112: return GET_ACCEL (112);
8838 case 120: return GET_ACCEL (120);
8839 case 121: return GET_ACCEL (121);
8840 case 122: return GET_ACCEL (122);
8841 case 124: return GET_ACCEL (124);
8842 case 130: return GET_ACCEL (130);
8843 case 131: return GET_ACCEL (131);
8844 case 132: return GET_ACCEL (132);
8845 case 133: return GET_ACCEL (133);
8846 case 140: return GET_ACCEL (140);
8847 case 141: return GET_ACCEL (141);
8848 case 150: return GET_ACCEL (150);
8849 case 160: return GET_ACCEL (160);
8850 case 190: return GET_ACCEL (190);
8851 case 200: return GET_ACCEL (200);
8852 case 300: return GET_ACCEL (300);
8853 case 400: return GET_ACCEL (400);
8854 case 500: return GET_ACCEL (500);
8855 case 501: return GET_ACCEL (501);
8856 case 900: return GET_ACCEL (900);
8857 case 910: return GET_ACCEL (910);
8858 case 1000: return GET_ACCEL (1000);
8859 case 1100: return GET_ACCEL (1100);
8860 case 1400: return GET_ACCEL (1400);
8861 case 1410: return GET_ACCEL (1410);
8862 case 1420: return GET_ACCEL (1420);
8863 case 1421: return GET_ACCEL (1421);
8864 case 1430: return GET_ACCEL (1430);
8865 case 1440: return GET_ACCEL (1440);
8866 case 1441: return GET_ACCEL (1441);
8867 case 1450: return GET_ACCEL (1450);
8868 case 1460: return GET_ACCEL (1460);
8869 case 1500: return GET_ACCEL (1500);
8870 case 1600: return GET_ACCEL (1600);
8871 case 1700: return GET_ACCEL (1700);
8872 case 1710: return GET_ACCEL (1710);
8873 case 1711: return GET_ACCEL (1711);
8874 case 1720: return GET_ACCEL (1720);
8875 case 1722: return GET_ACCEL (1722);
8876 case 1730: return GET_ACCEL (1730);
8877 case 1731: return GET_ACCEL (1731);
8878 case 1740: return GET_ACCEL (1740);
8879 case 1750: return GET_ACCEL (1750);
8880 case 1760: return GET_ACCEL (1760);
8881 case 1800: return GET_ACCEL (1800);
8882 case 2100: return GET_ACCEL (2100);
8883 case 2400: return GET_ACCEL (2400);
8884 case 2410: return GET_ACCEL (2410);
8885 case 2500: return GET_ACCEL (2500);
8886 case 2600: return GET_ACCEL (2600);
8887 case 2611: return GET_ACCEL (2611);
8888 case 2612: return GET_ACCEL (2612);
8889 case 2711: return GET_ACCEL (2711);
8890 case 2811: return GET_ACCEL (2811);
8891 case 3000: return GET_ACCEL (3000);
8892 case 3100: return GET_ACCEL (3100);
8893 case 3200: return GET_ACCEL (3200);
8894 case 3710: return GET_ACCEL (3710);
8895 case 3711: return GET_ACCEL (3711);
8896 case 3800: return GET_ACCEL (3800);
8897 case 4300: return GET_ACCEL (4300);
8898 case 4400: return GET_ACCEL (4400);
8899 case 4500: return GET_ACCEL (4500);
8900 case 4700: return GET_ACCEL (4700);
8901 case 4800: return GET_ACCEL (4800);
8902 case 4900: return GET_ACCEL (4900);
8903 case 5000: return GET_ACCEL (5000);
8904 case 5100: return GET_ACCEL (5100);
8905 case 5200: return GET_ACCEL (5200);
8906 case 5300: return GET_ACCEL (5300);
8907 case 5400: return GET_ACCEL (5400);
8908 case 5500: return GET_ACCEL (5500);
8909 case 5600: return GET_ACCEL (5600);
8910 case 5700: return GET_ACCEL (5700);
8911 case 5800: return GET_ACCEL (5800);
8912 case 6000: return GET_ACCEL (6000);
8913 case 6100: return GET_ACCEL (6100);
8914 case 6211: return GET_ACCEL (6211);
8915 case 6212: return GET_ACCEL (6212);
8916 case 6213: return GET_ACCEL (6213);
8917 case 6221: return GET_ACCEL (6221);
8918 case 6222: return GET_ACCEL (6222);
8919 case 6223: return GET_ACCEL (6223);
8920 case 6231: return GET_ACCEL (6231);
8921 case 6232: return GET_ACCEL (6232);
8922 case 6233: return GET_ACCEL (6233);
8923 case 6241: return GET_ACCEL (6241);
8924 case 6242: return GET_ACCEL (6242);
8925 case 6243: return GET_ACCEL (6243);
8926 case 6300: return GET_ACCEL (6300);
8927 case 6400: return GET_ACCEL (6400);
8928 case 6500: return GET_ACCEL (6500);
8929 case 6600: return GET_ACCEL (6600);
8930 case 6700: return GET_ACCEL (6700);
8931 case 6800: return GET_ACCEL (6800);
8932 case 6900: return GET_ACCEL (6900);
8933 case 7100: return GET_ACCEL (7100);
8934 case 7200: return GET_ACCEL (7200);
8935 case 7300: return GET_ACCEL (7300);
8936 case 7400: return GET_ACCEL (7400);
8937 case 7500: return GET_ACCEL (7500);
8938 case 7600: return GET_ACCEL (7600);
8939 case 7700: return GET_ACCEL (7700);
8940 case 7800: return GET_ACCEL (7800);
8941 case 7900: return GET_ACCEL (7900);
8942 case 8000: return GET_ACCEL (8000);
8943 case 8100: return GET_ACCEL (8100);
8944 case 8200: return GET_ACCEL (8200);
8945 case 8300: return GET_ACCEL (8300);
8946 case 8400: return GET_ACCEL (8400);
8947 case 8500: return GET_ACCEL (8500);
8948 case 8600: return GET_ACCEL (8600);
8949 case 8700: return GET_ACCEL (8700);
8950 case 8800: return GET_ACCEL (8800);
8951 case 8900: return GET_ACCEL (8900);
8952 case 9000: return GET_ACCEL (9000);
8953 case 9100: return GET_ACCEL (9100);
8954 case 9200: return GET_ACCEL (9200);
8955 case 9300: return GET_ACCEL (9300);
8956 case 9400: return GET_ACCEL (9400);
8957 case 9500: return GET_ACCEL (9500);
8958 case 9600: return GET_ACCEL (9600);
8959 case 9700: return GET_ACCEL (9700);
8960 case 9710: return GET_ACCEL (9710);
8961 case 9720: return GET_ACCEL (9720);
8962 case 9800: return GET_ACCEL (9800);
8963 case 9810: return GET_ACCEL (9810);
8964 case 9820: return GET_ACCEL (9820);
8965 case 9900: return GET_ACCEL (9900);
8966 case 10000: return GET_ACCEL (10000);
8967 case 10100: return GET_ACCEL (10100);
8968 case 10200: return GET_ACCEL (10200);
8969 case 10300: return GET_ACCEL (10300);
8970 case 10400: return GET_ACCEL (10400);
8971 case 10410: return GET_ACCEL (10410);
8972 case 10420: return GET_ACCEL (10420);
8973 case 10500: return GET_ACCEL (10500);
8974 case 10600: return GET_ACCEL (10600);
8975 case 10700: return GET_ACCEL (10700);
8976 case 10800: return GET_ACCEL (10800);
8977 case 10900: return GET_ACCEL (10900);
8978 case 11000: return GET_ACCEL (11000);
8979 case 11100: return GET_ACCEL (11100);
8980 case 11200: return GET_ACCEL (11200);
8981 case 11300: return GET_ACCEL (11300);
8982 case 11400: return GET_ACCEL (11400);
8983 case 11500: return GET_ACCEL (11500);
8984 case 11600: return GET_ACCEL (11600);
8985 case 11700: return GET_ACCEL (11700);
8986 case 11800: return GET_ACCEL (11800);
8987 case 11900: return GET_ACCEL (11900);
8988 case 12000: return GET_ACCEL (12000);
8989 case 12100: return GET_ACCEL (12100);
8990 case 12200: return GET_ACCEL (12200);
8991 case 12300: return GET_ACCEL (12300);
8992 case 12400: return GET_ACCEL (12400);
8993 case 12500: return GET_ACCEL (12500);
8994 case 12600: return GET_ACCEL (12600);
8995 case 12700: return GET_ACCEL (12700);
8996 case 12800: return GET_ACCEL (12800);
9002 uint
set_gpu_loops (uint hash_mode
)
9006 case 0: return GET_LOOPS (0);
9007 case 10: return GET_LOOPS (10);
9008 case 11: return GET_LOOPS (11);
9009 case 12: return GET_LOOPS (12);
9010 case 20: return GET_LOOPS (20);
9011 case 21: return GET_LOOPS (21);
9012 case 22: return GET_LOOPS (22);
9013 case 23: return GET_LOOPS (23);
9014 case 30: return GET_LOOPS (30);
9015 case 40: return GET_LOOPS (40);
9016 case 50: return GET_LOOPS (50);
9017 case 60: return GET_LOOPS (60);
9018 case 100: return GET_LOOPS (100);
9019 case 101: return GET_LOOPS (101);
9020 case 110: return GET_LOOPS (110);
9021 case 111: return GET_LOOPS (111);
9022 case 112: return GET_LOOPS (112);
9023 case 120: return GET_LOOPS (120);
9024 case 121: return GET_LOOPS (121);
9025 case 122: return GET_LOOPS (122);
9026 case 124: return GET_LOOPS (124);
9027 case 130: return GET_LOOPS (130);
9028 case 131: return GET_LOOPS (131);
9029 case 132: return GET_LOOPS (132);
9030 case 133: return GET_LOOPS (133);
9031 case 140: return GET_LOOPS (140);
9032 case 141: return GET_LOOPS (141);
9033 case 150: return GET_LOOPS (150);
9034 case 160: return GET_LOOPS (160);
9035 case 190: return GET_LOOPS (190);
9036 case 200: return GET_LOOPS (200);
9037 case 300: return GET_LOOPS (300);
9038 case 400: return GET_LOOPS (400);
9039 case 500: return GET_LOOPS (500);
9040 case 501: return GET_LOOPS (501);
9041 case 900: return GET_LOOPS (900);
9042 case 910: return GET_LOOPS (910);
9043 case 1000: return GET_LOOPS (1000);
9044 case 1100: return GET_LOOPS (1100);
9045 case 1400: return GET_LOOPS (1400);
9046 case 1410: return GET_LOOPS (1410);
9047 case 1420: return GET_LOOPS (1420);
9048 case 1421: return GET_LOOPS (1421);
9049 case 1430: return GET_LOOPS (1430);
9050 case 1440: return GET_LOOPS (1440);
9051 case 1441: return GET_LOOPS (1441);
9052 case 1450: return GET_LOOPS (1450);
9053 case 1460: return GET_LOOPS (1460);
9054 case 1500: return GET_LOOPS (1500);
9055 case 1600: return GET_LOOPS (1600);
9056 case 1700: return GET_LOOPS (1700);
9057 case 1710: return GET_LOOPS (1710);
9058 case 1711: return GET_LOOPS (1711);
9059 case 1720: return GET_LOOPS (1720);
9060 case 1722: return GET_LOOPS (1722);
9061 case 1730: return GET_LOOPS (1730);
9062 case 1731: return GET_LOOPS (1731);
9063 case 1740: return GET_LOOPS (1740);
9064 case 1750: return GET_LOOPS (1750);
9065 case 1760: return GET_LOOPS (1760);
9066 case 1800: return GET_LOOPS (1800);
9067 case 2100: return GET_LOOPS (2100);
9068 case 2400: return GET_LOOPS (2400);
9069 case 2410: return GET_LOOPS (2410);
9070 case 2500: return GET_LOOPS (2500);
9071 case 2600: return GET_LOOPS (2600);
9072 case 2611: return GET_LOOPS (2611);
9073 case 2612: return GET_LOOPS (2612);
9074 case 2711: return GET_LOOPS (2711);
9075 case 2811: return GET_LOOPS (2811);
9076 case 3000: return GET_LOOPS (3000);
9077 case 3100: return GET_LOOPS (3100);
9078 case 3200: return GET_LOOPS (3200);
9079 case 3710: return GET_LOOPS (3710);
9080 case 3711: return GET_LOOPS (3711);
9081 case 3800: return GET_LOOPS (3800);
9082 case 4300: return GET_LOOPS (4300);
9083 case 4400: return GET_LOOPS (4400);
9084 case 4500: return GET_LOOPS (4500);
9085 case 4700: return GET_LOOPS (4700);
9086 case 4800: return GET_LOOPS (4800);
9087 case 4900: return GET_LOOPS (4900);
9088 case 5000: return GET_LOOPS (5000);
9089 case 5100: return GET_LOOPS (5100);
9090 case 5200: return GET_LOOPS (5200);
9091 case 5300: return GET_LOOPS (5300);
9092 case 5400: return GET_LOOPS (5400);
9093 case 5500: return GET_LOOPS (5500);
9094 case 5600: return GET_LOOPS (5600);
9095 case 5700: return GET_LOOPS (5700);
9096 case 5800: return GET_LOOPS (5800);
9097 case 6000: return GET_LOOPS (6000);
9098 case 6100: return GET_LOOPS (6100);
9099 case 6211: return GET_LOOPS (6211);
9100 case 6212: return GET_LOOPS (6212);
9101 case 6213: return GET_LOOPS (6213);
9102 case 6221: return GET_LOOPS (6221);
9103 case 6222: return GET_LOOPS (6222);
9104 case 6223: return GET_LOOPS (6223);
9105 case 6231: return GET_LOOPS (6231);
9106 case 6232: return GET_LOOPS (6232);
9107 case 6233: return GET_LOOPS (6233);
9108 case 6241: return GET_LOOPS (6241);
9109 case 6242: return GET_LOOPS (6242);
9110 case 6243: return GET_LOOPS (6243);
9111 case 6300: return GET_LOOPS (6300);
9112 case 6400: return GET_LOOPS (6400);
9113 case 6500: return GET_LOOPS (6500);
9114 case 6600: return GET_LOOPS (6600);
9115 case 6700: return GET_LOOPS (6700);
9116 case 6800: return GET_LOOPS (6800);
9117 case 6900: return GET_LOOPS (6900);
9118 case 7100: return GET_LOOPS (7100);
9119 case 7200: return GET_LOOPS (7200);
9120 case 7300: return GET_LOOPS (7300);
9121 case 7400: return GET_LOOPS (7400);
9122 case 7500: return GET_LOOPS (7500);
9123 case 7600: return GET_LOOPS (7600);
9124 case 7700: return GET_LOOPS (7700);
9125 case 7800: return GET_LOOPS (7800);
9126 case 7900: return GET_LOOPS (7900);
9127 case 8000: return GET_LOOPS (8000);
9128 case 8100: return GET_LOOPS (8100);
9129 case 8200: return GET_LOOPS (8200);
9130 case 8300: return GET_LOOPS (8300);
9131 case 8400: return GET_LOOPS (8400);
9132 case 8500: return GET_LOOPS (8500);
9133 case 8600: return GET_LOOPS (8600);
9134 case 8700: return GET_LOOPS (8700);
9135 case 8800: return GET_LOOPS (8800);
9136 case 8900: return GET_LOOPS (8900);
9137 case 9000: return GET_LOOPS (9000);
9138 case 9100: return GET_LOOPS (9100);
9139 case 9200: return GET_LOOPS (9200);
9140 case 9300: return GET_LOOPS (9300);
9141 case 9400: return GET_LOOPS (9400);
9142 case 9500: return GET_LOOPS (9500);
9143 case 9600: return GET_LOOPS (9600);
9144 case 9700: return GET_LOOPS (9700);
9145 case 9710: return GET_LOOPS (9710);
9146 case 9720: return GET_LOOPS (9720);
9147 case 9800: return GET_LOOPS (9800);
9148 case 9810: return GET_LOOPS (9810);
9149 case 9820: return GET_LOOPS (9820);
9150 case 9900: return GET_LOOPS (9900);
9151 case 10000: return GET_LOOPS (10000);
9152 case 10100: return GET_LOOPS (10100);
9153 case 10200: return GET_LOOPS (10200);
9154 case 10300: return GET_LOOPS (10300);
9155 case 10400: return GET_LOOPS (10400);
9156 case 10410: return GET_LOOPS (10410);
9157 case 10420: return GET_LOOPS (10420);
9158 case 10500: return GET_LOOPS (10500);
9159 case 10600: return GET_LOOPS (10600);
9160 case 10700: return GET_LOOPS (10700);
9161 case 10800: return GET_LOOPS (10800);
9162 case 10900: return GET_LOOPS (10900);
9163 case 11000: return GET_LOOPS (11000);
9164 case 11100: return GET_LOOPS (11100);
9165 case 11200: return GET_LOOPS (11200);
9166 case 11300: return GET_LOOPS (11300);
9167 case 11400: return GET_LOOPS (11400);
9168 case 11500: return GET_LOOPS (11500);
9169 case 11600: return GET_LOOPS (11600);
9170 case 11700: return GET_LOOPS (11700);
9171 case 11800: return GET_LOOPS (11800);
9172 case 11900: return GET_LOOPS (11900);
9173 case 12000: return GET_LOOPS (12000);
9174 case 12100: return GET_LOOPS (12100);
9175 case 12200: return GET_LOOPS (12200);
9176 case 12300: return GET_LOOPS (12300);
9177 case 12400: return GET_LOOPS (12400);
9178 case 12500: return GET_LOOPS (12500);
9179 case 12600: return GET_LOOPS (12600);
9180 case 12700: return GET_LOOPS (12700);
9181 case 12800: return GET_LOOPS (12800);
9191 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9195 if (salt_len
> sizeof(tmp
))
9200 memset (tmp
, 0, sizeof (tmp
));
9201 memcpy (tmp
, in
, salt_len
);
9203 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9205 if ((salt_len
% 2) == 0)
9207 uint new_salt_len
= salt_len
/ 2;
9209 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9211 char p0
= tmp
[j
+ 0];
9212 char p1
= tmp
[j
+ 1];
9214 tmp
[i
] = hex_convert (p1
) << 0;
9215 tmp
[i
] |= hex_convert (p0
) << 4;
9218 salt_len
= new_salt_len
;
9225 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9227 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9230 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9232 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9236 uint
*tmp_uint
= (uint
*) tmp
;
9238 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9239 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9240 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9241 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9242 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9243 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9244 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9245 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9246 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9247 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9249 salt_len
= salt_len
* 2;
9257 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9259 lowercase (tmp
, salt_len
);
9262 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9264 uppercase (tmp
, salt_len
);
9267 uint len
= salt_len
;
9269 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9274 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9279 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9281 uint
*tmp_uint
= (uint
*) tmp
;
9287 for (uint i
= 0; i
< max
; i
++)
9289 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9292 // Important: we may need to increase the length of memcpy since
9293 // we don't want to "loose" some swapped bytes (could happen if
9294 // they do not perfectly fit in the 4-byte blocks)
9295 // Memcpy does always copy the bytes in the BE order, but since
9296 // we swapped them, some important bytes could be in positions
9297 // we normally skip with the original len
9299 if (len
% 4) len
+= 4 - (len
% 4);
9302 memcpy (out
, tmp
, len
);
9307 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9309 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9311 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9313 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9315 salt_t
*salt
= hash_buf
->salt
;
9317 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9319 char *iter_pos
= input_buf
+ 4;
9321 salt
->salt_iter
= 1 << atoi (iter_pos
);
9323 char *salt_pos
= strchr (iter_pos
, '$');
9325 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9331 salt
->salt_len
= salt_len
;
9335 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9337 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9339 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9341 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9343 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9344 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9345 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9346 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9348 char *hash_pos
= salt_pos
+ 22;
9350 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9352 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9354 memcpy (digest
, tmp_buf
, 24);
9356 digest
[0] = byte_swap_32 (digest
[0]);
9357 digest
[1] = byte_swap_32 (digest
[1]);
9358 digest
[2] = byte_swap_32 (digest
[2]);
9359 digest
[3] = byte_swap_32 (digest
[3]);
9360 digest
[4] = byte_swap_32 (digest
[4]);
9361 digest
[5] = byte_swap_32 (digest
[5]);
9363 digest
[5] &= ~0xff; // its just 23 not 24 !
9368 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9370 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9372 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9376 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9378 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9380 memcpy (digest
, tmp_buf
, 32);
9382 digest
[0] = byte_swap_32 (digest
[0]);
9383 digest
[1] = byte_swap_32 (digest
[1]);
9384 digest
[2] = byte_swap_32 (digest
[2]);
9385 digest
[3] = byte_swap_32 (digest
[3]);
9386 digest
[4] = byte_swap_32 (digest
[4]);
9387 digest
[5] = byte_swap_32 (digest
[5]);
9388 digest
[6] = byte_swap_32 (digest
[6]);
9389 digest
[7] = byte_swap_32 (digest
[7]);
9391 digest
[0] -= SHA256M_A
;
9392 digest
[1] -= SHA256M_B
;
9393 digest
[2] -= SHA256M_C
;
9394 digest
[3] -= SHA256M_D
;
9395 digest
[4] -= SHA256M_E
;
9396 digest
[5] -= SHA256M_F
;
9397 digest
[6] -= SHA256M_G
;
9398 digest
[7] -= SHA256M_H
;
9403 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9405 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9407 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9409 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9410 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9412 digest
[0] = byte_swap_32 (digest
[0]);
9413 digest
[1] = byte_swap_32 (digest
[1]);
9417 IP (digest
[0], digest
[1], tt
);
9419 digest
[0] = digest
[0];
9420 digest
[1] = digest
[1];
9427 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9429 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9431 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9433 salt_t
*salt
= hash_buf
->salt
;
9435 char *hash_pos
= input_buf
+ 8;
9437 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9438 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9439 digest
[2] = hex_to_uint (&hash_pos
[16]);
9440 digest
[3] = hex_to_uint (&hash_pos
[24]);
9441 digest
[4] = hex_to_uint (&hash_pos
[32]);
9443 digest
[0] -= SHA1M_A
;
9444 digest
[1] -= SHA1M_B
;
9445 digest
[2] -= SHA1M_C
;
9446 digest
[3] -= SHA1M_D
;
9447 digest
[4] -= SHA1M_E
;
9451 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9453 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9455 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9457 salt
->salt_len
= salt_len
;
9462 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9464 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9466 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9468 salt_t
*salt
= hash_buf
->salt
;
9470 char *hash_pos
= input_buf
+ 8;
9472 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9473 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9474 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9475 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9476 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9477 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9478 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9479 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9481 digest
[0] -= SHA512M_A
;
9482 digest
[1] -= SHA512M_B
;
9483 digest
[2] -= SHA512M_C
;
9484 digest
[3] -= SHA512M_D
;
9485 digest
[4] -= SHA512M_E
;
9486 digest
[5] -= SHA512M_F
;
9487 digest
[6] -= SHA512M_G
;
9488 digest
[7] -= SHA512M_H
;
9492 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9494 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9496 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9498 salt
->salt_len
= salt_len
;
9503 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9505 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9507 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9511 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9514 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9516 salt_t
*salt
= hash_buf
->salt
;
9518 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9519 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9520 digest
[2] = hex_to_uint (&input_buf
[16]);
9521 digest
[3] = hex_to_uint (&input_buf
[24]);
9523 digest
[0] = byte_swap_32 (digest
[0]);
9524 digest
[1] = byte_swap_32 (digest
[1]);
9525 digest
[2] = byte_swap_32 (digest
[2]);
9526 digest
[3] = byte_swap_32 (digest
[3]);
9528 digest
[0] -= MD5M_A
;
9529 digest
[1] -= MD5M_B
;
9530 digest
[2] -= MD5M_C
;
9531 digest
[3] -= MD5M_D
;
9533 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9535 uint salt_len
= input_len
- 32 - 1;
9537 char *salt_buf
= input_buf
+ 32 + 1;
9539 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9541 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9543 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9545 salt
->salt_len
= salt_len
;
9550 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9552 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9554 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9558 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9563 char clean_input_buf
[32];
9565 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9566 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9568 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9572 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9578 clean_input_buf
[k
] = input_buf
[i
];
9586 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9588 salt_t
*salt
= hash_buf
->salt
;
9590 char a
, b
, c
, d
, e
, f
;
9592 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9593 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9594 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9595 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9596 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9597 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9599 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9600 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9602 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9603 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9604 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9605 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9606 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9607 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9609 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9610 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9612 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9613 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9614 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9615 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9616 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9617 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9619 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9620 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9622 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9623 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9624 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9625 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9626 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9627 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9629 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9630 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9632 digest
[0] = byte_swap_32 (digest
[0]);
9633 digest
[1] = byte_swap_32 (digest
[1]);
9634 digest
[2] = byte_swap_32 (digest
[2]);
9635 digest
[3] = byte_swap_32 (digest
[3]);
9637 digest
[0] -= MD5M_A
;
9638 digest
[1] -= MD5M_B
;
9639 digest
[2] -= MD5M_C
;
9640 digest
[3] -= MD5M_D
;
9642 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9644 uint salt_len
= input_len
- 30 - 1;
9646 char *salt_buf
= input_buf
+ 30 + 1;
9648 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9650 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9652 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9653 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9655 salt
->salt_len
= salt_len
;
9657 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9659 salt
->salt_len
+= 22;
9664 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9666 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9668 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9672 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9675 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9677 salt_t
*salt
= hash_buf
->salt
;
9679 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9680 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9681 digest
[2] = hex_to_uint (&input_buf
[16]);
9682 digest
[3] = hex_to_uint (&input_buf
[24]);
9683 digest
[4] = hex_to_uint (&input_buf
[32]);
9685 digest
[0] -= SHA1M_A
;
9686 digest
[1] -= SHA1M_B
;
9687 digest
[2] -= SHA1M_C
;
9688 digest
[3] -= SHA1M_D
;
9689 digest
[4] -= SHA1M_E
;
9691 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9693 uint salt_len
= input_len
- 40 - 1;
9695 char *salt_buf
= input_buf
+ 40 + 1;
9697 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9699 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9701 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9703 salt
->salt_len
= salt_len
;
9708 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9710 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9712 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9716 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9719 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9721 char *iter_pos
= input_buf
+ 6;
9723 salt_t
*salt
= hash_buf
->salt
;
9725 salt
->salt_iter
= atoi (iter_pos
) - 1;
9727 char *salt_pos
= strchr (iter_pos
, '#');
9729 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9733 char *digest_pos
= strchr (salt_pos
, '#');
9735 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9739 uint salt_len
= digest_pos
- salt_pos
- 1;
9741 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9743 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9744 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9745 digest
[2] = hex_to_uint (&digest_pos
[16]);
9746 digest
[3] = hex_to_uint (&digest_pos
[24]);
9748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9750 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9752 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9754 salt
->salt_len
= salt_len
;
9759 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9761 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9763 salt_t
*salt
= hash_buf
->salt
;
9765 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9769 memcpy (&in
, input_buf
, input_len
);
9771 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9773 memcpy (digest
, in
.keymic
, 16);
9776 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9777 The phrase "Pairwise key expansion"
9778 Access Point Address (Referred to as Authenticator Address AA)
9779 Supplicant Address (referred to as Supplicant Address SA)
9780 Access Point Nonce (referred to as Authenticator Anonce)
9781 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9784 uint salt_len
= strlen (in
.essid
);
9786 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9788 salt
->salt_len
= salt_len
;
9790 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9792 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9794 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9796 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9798 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9799 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9803 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9804 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9807 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9809 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9810 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9814 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9815 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9818 for (int i
= 0; i
< 25; i
++)
9820 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9823 wpa
->keyver
= in
.keyver
;
9825 if (wpa
->keyver
> 255)
9827 log_info ("ATTENTION!");
9828 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9829 log_info (" This could be due to a recent aircrack-ng bug.");
9830 log_info (" The key version was automatically reset to a reasonable value.");
9833 wpa
->keyver
&= 0xff;
9836 wpa
->eapol_size
= in
.eapol_size
;
9838 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9840 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9842 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9844 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9846 if (wpa
->keyver
== 1)
9852 digest
[0] = byte_swap_32 (digest
[0]);
9853 digest
[1] = byte_swap_32 (digest
[1]);
9854 digest
[2] = byte_swap_32 (digest
[2]);
9855 digest
[3] = byte_swap_32 (digest
[3]);
9857 for (int i
= 0; i
< 64; i
++)
9859 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9863 salt
->salt_buf
[10] = digest
[1];
9864 salt
->salt_buf
[11] = digest
[2];
9869 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9871 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9873 salt_t
*salt
= hash_buf
->salt
;
9877 log_error ("Password Safe v2 container not specified");
9882 FILE *fp
= fopen (input_buf
, "rb");
9886 log_error ("%s: %s", input_buf
, strerror (errno
));
9895 uint32_t salt
[5]; // unused, but makes better valid check
9896 uint32_t iv
[2]; // unused, but makes better valid check
9902 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9906 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9908 salt
->salt_buf
[0] = buf
.random
[0];
9909 salt
->salt_buf
[1] = buf
.random
[1];
9912 salt
->salt_iter
= 1000;
9914 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9915 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9916 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9917 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9918 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9923 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9925 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9927 salt_t
*salt
= hash_buf
->salt
;
9931 log_error (".psafe3 not specified");
9936 FILE *fp
= fopen (input_buf
, "rb");
9940 log_error ("%s: %s", input_buf
, strerror (errno
));
9947 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9951 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9953 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9955 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9957 salt
->salt_iter
= in
.iterations
+ 1;
9959 salt
->salt_buf
[0] = in
.salt_buf
[0];
9960 salt
->salt_buf
[1] = in
.salt_buf
[1];
9961 salt
->salt_buf
[2] = in
.salt_buf
[2];
9962 salt
->salt_buf
[3] = in
.salt_buf
[3];
9963 salt
->salt_buf
[4] = in
.salt_buf
[4];
9964 salt
->salt_buf
[5] = in
.salt_buf
[5];
9965 salt
->salt_buf
[6] = in
.salt_buf
[6];
9966 salt
->salt_buf
[7] = in
.salt_buf
[7];
9968 salt
->salt_len
= 32;
9970 digest
[0] = in
.hash_buf
[0];
9971 digest
[1] = in
.hash_buf
[1];
9972 digest
[2] = in
.hash_buf
[2];
9973 digest
[3] = in
.hash_buf
[3];
9974 digest
[4] = in
.hash_buf
[4];
9975 digest
[5] = in
.hash_buf
[5];
9976 digest
[6] = in
.hash_buf
[6];
9977 digest
[7] = in
.hash_buf
[7];
9979 digest
[0] = byte_swap_32 (digest
[0]);
9980 digest
[1] = byte_swap_32 (digest
[1]);
9981 digest
[2] = byte_swap_32 (digest
[2]);
9982 digest
[3] = byte_swap_32 (digest
[3]);
9983 digest
[4] = byte_swap_32 (digest
[4]);
9984 digest
[5] = byte_swap_32 (digest
[5]);
9985 digest
[6] = byte_swap_32 (digest
[6]);
9986 digest
[7] = byte_swap_32 (digest
[7]);
9991 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9993 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
9995 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
9997 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9999 salt_t
*salt
= hash_buf
->salt
;
10001 char *iter_pos
= input_buf
+ 3;
10003 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10005 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10007 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10009 salt
->salt_iter
= salt_iter
;
10011 char *salt_pos
= iter_pos
+ 1;
10015 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10017 salt
->salt_len
= salt_len
;
10019 char *hash_pos
= salt_pos
+ salt_len
;
10021 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10023 return (PARSER_OK
);
10026 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10028 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10030 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10032 salt_t
*salt
= hash_buf
->salt
;
10034 char *salt_pos
= input_buf
+ 3;
10036 uint iterations_len
= 0;
10038 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10042 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10044 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10045 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10049 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10053 iterations_len
+= 8;
10057 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10060 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10062 char *hash_pos
= strchr (salt_pos
, '$');
10064 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10066 uint salt_len
= hash_pos
- salt_pos
;
10068 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10070 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10072 salt
->salt_len
= salt_len
;
10076 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10078 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10080 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10082 return (PARSER_OK
);
10085 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10087 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10089 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10091 salt_t
*salt
= hash_buf
->salt
;
10093 char *salt_pos
= input_buf
+ 6;
10095 uint iterations_len
= 0;
10097 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10101 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10103 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10104 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10108 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10112 iterations_len
+= 8;
10116 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10119 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10121 char *hash_pos
= strchr (salt_pos
, '$');
10123 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10125 uint salt_len
= hash_pos
- salt_pos
;
10127 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10129 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10131 salt
->salt_len
= salt_len
;
10135 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10137 return (PARSER_OK
);
10140 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10142 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10144 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10146 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10148 salt_t
*salt
= hash_buf
->salt
;
10150 char *salt_pos
= input_buf
+ 14;
10152 char *hash_pos
= strchr (salt_pos
, '*');
10154 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10158 uint salt_len
= hash_pos
- salt_pos
- 1;
10160 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10162 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10164 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10166 salt
->salt_len
= salt_len
;
10168 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10170 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10172 memcpy (digest
, tmp_buf
, 20);
10174 digest
[0] = byte_swap_32 (digest
[0]);
10175 digest
[1] = byte_swap_32 (digest
[1]);
10176 digest
[2] = byte_swap_32 (digest
[2]);
10177 digest
[3] = byte_swap_32 (digest
[3]);
10178 digest
[4] = byte_swap_32 (digest
[4]);
10180 digest
[0] -= SHA1M_A
;
10181 digest
[1] -= SHA1M_B
;
10182 digest
[2] -= SHA1M_C
;
10183 digest
[3] -= SHA1M_D
;
10184 digest
[4] -= SHA1M_E
;
10186 return (PARSER_OK
);
10189 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10191 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10193 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10195 if (c12
& 3) return (PARSER_HASH_VALUE
);
10197 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10199 salt_t
*salt
= hash_buf
->salt
;
10201 // for ascii_digest
10202 salt
->salt_sign
[0] = input_buf
[0];
10203 salt
->salt_sign
[1] = input_buf
[1];
10205 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10206 | itoa64_to_int (input_buf
[1]) << 6;
10208 salt
->salt_len
= 2;
10212 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10214 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10216 memcpy (digest
, tmp_buf
, 8);
10220 IP (digest
[0], digest
[1], tt
);
10225 return (PARSER_OK
);
10228 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10230 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10232 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10234 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10235 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10236 digest
[2] = hex_to_uint (&input_buf
[16]);
10237 digest
[3] = hex_to_uint (&input_buf
[24]);
10239 digest
[0] = byte_swap_32 (digest
[0]);
10240 digest
[1] = byte_swap_32 (digest
[1]);
10241 digest
[2] = byte_swap_32 (digest
[2]);
10242 digest
[3] = byte_swap_32 (digest
[3]);
10244 digest
[0] -= MD4M_A
;
10245 digest
[1] -= MD4M_B
;
10246 digest
[2] -= MD4M_C
;
10247 digest
[3] -= MD4M_D
;
10249 return (PARSER_OK
);
10252 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10254 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10256 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10260 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10263 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10265 salt_t
*salt
= hash_buf
->salt
;
10267 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10268 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10269 digest
[2] = hex_to_uint (&input_buf
[16]);
10270 digest
[3] = hex_to_uint (&input_buf
[24]);
10272 digest
[0] = byte_swap_32 (digest
[0]);
10273 digest
[1] = byte_swap_32 (digest
[1]);
10274 digest
[2] = byte_swap_32 (digest
[2]);
10275 digest
[3] = byte_swap_32 (digest
[3]);
10277 digest
[0] -= MD4M_A
;
10278 digest
[1] -= MD4M_B
;
10279 digest
[2] -= MD4M_C
;
10280 digest
[3] -= MD4M_D
;
10282 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10284 uint salt_len
= input_len
- 32 - 1;
10286 char *salt_buf
= input_buf
+ 32 + 1;
10288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10290 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10294 salt
->salt_len
= salt_len
;
10296 return (PARSER_OK
);
10299 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10301 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10303 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10305 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10306 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10307 digest
[2] = hex_to_uint (&input_buf
[16]);
10308 digest
[3] = hex_to_uint (&input_buf
[24]);
10310 digest
[0] = byte_swap_32 (digest
[0]);
10311 digest
[1] = byte_swap_32 (digest
[1]);
10312 digest
[2] = byte_swap_32 (digest
[2]);
10313 digest
[3] = byte_swap_32 (digest
[3]);
10315 digest
[0] -= MD5M_A
;
10316 digest
[1] -= MD5M_B
;
10317 digest
[2] -= MD5M_C
;
10318 digest
[3] -= MD5M_D
;
10320 return (PARSER_OK
);
10323 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10325 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10327 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10329 digest
[0] = hex_to_uint (&input_buf
[0]);
10330 digest
[1] = hex_to_uint (&input_buf
[8]);
10334 digest
[0] = byte_swap_32 (digest
[0]);
10335 digest
[1] = byte_swap_32 (digest
[1]);
10337 return (PARSER_OK
);
10340 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10342 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10344 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10348 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10351 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10353 salt_t
*salt
= hash_buf
->salt
;
10355 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10356 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10357 digest
[2] = hex_to_uint (&input_buf
[16]);
10358 digest
[3] = hex_to_uint (&input_buf
[24]);
10360 digest
[0] = byte_swap_32 (digest
[0]);
10361 digest
[1] = byte_swap_32 (digest
[1]);
10362 digest
[2] = byte_swap_32 (digest
[2]);
10363 digest
[3] = byte_swap_32 (digest
[3]);
10365 digest
[0] -= MD5M_A
;
10366 digest
[1] -= MD5M_B
;
10367 digest
[2] -= MD5M_C
;
10368 digest
[3] -= MD5M_D
;
10370 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10372 uint salt_len
= input_len
- 32 - 1;
10374 char *salt_buf
= input_buf
+ 32 + 1;
10376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10378 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10380 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10382 salt
->salt_len
= salt_len
;
10384 return (PARSER_OK
);
10387 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10389 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10391 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10393 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10394 | itoa64_to_int (input_buf
[ 1]) << 6
10395 | itoa64_to_int (input_buf
[ 2]) << 12
10396 | itoa64_to_int (input_buf
[ 3]) << 18;
10397 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10398 | itoa64_to_int (input_buf
[ 5]) << 6
10399 | itoa64_to_int (input_buf
[ 6]) << 12
10400 | itoa64_to_int (input_buf
[ 7]) << 18;
10401 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10402 | itoa64_to_int (input_buf
[ 9]) << 6
10403 | itoa64_to_int (input_buf
[10]) << 12
10404 | itoa64_to_int (input_buf
[11]) << 18;
10405 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10406 | itoa64_to_int (input_buf
[13]) << 6
10407 | itoa64_to_int (input_buf
[14]) << 12
10408 | itoa64_to_int (input_buf
[15]) << 18;
10410 digest
[0] -= MD5M_A
;
10411 digest
[1] -= MD5M_B
;
10412 digest
[2] -= MD5M_C
;
10413 digest
[3] -= MD5M_D
;
10415 digest
[0] &= 0x00ffffff;
10416 digest
[1] &= 0x00ffffff;
10417 digest
[2] &= 0x00ffffff;
10418 digest
[3] &= 0x00ffffff;
10420 return (PARSER_OK
);
10423 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10425 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10427 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10431 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10434 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10436 salt_t
*salt
= hash_buf
->salt
;
10438 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10439 | itoa64_to_int (input_buf
[ 1]) << 6
10440 | itoa64_to_int (input_buf
[ 2]) << 12
10441 | itoa64_to_int (input_buf
[ 3]) << 18;
10442 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10443 | itoa64_to_int (input_buf
[ 5]) << 6
10444 | itoa64_to_int (input_buf
[ 6]) << 12
10445 | itoa64_to_int (input_buf
[ 7]) << 18;
10446 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10447 | itoa64_to_int (input_buf
[ 9]) << 6
10448 | itoa64_to_int (input_buf
[10]) << 12
10449 | itoa64_to_int (input_buf
[11]) << 18;
10450 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10451 | itoa64_to_int (input_buf
[13]) << 6
10452 | itoa64_to_int (input_buf
[14]) << 12
10453 | itoa64_to_int (input_buf
[15]) << 18;
10455 digest
[0] -= MD5M_A
;
10456 digest
[1] -= MD5M_B
;
10457 digest
[2] -= MD5M_C
;
10458 digest
[3] -= MD5M_D
;
10460 digest
[0] &= 0x00ffffff;
10461 digest
[1] &= 0x00ffffff;
10462 digest
[2] &= 0x00ffffff;
10463 digest
[3] &= 0x00ffffff;
10465 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10467 uint salt_len
= input_len
- 16 - 1;
10469 char *salt_buf
= input_buf
+ 16 + 1;
10471 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10473 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10475 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10477 salt
->salt_len
= salt_len
;
10479 return (PARSER_OK
);
10482 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10484 key
[0] = (nthash
[0] >> 0);
10485 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10486 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10487 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10488 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10489 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10490 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10491 key
[7] = (nthash
[6] << 1);
10503 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10505 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10507 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10509 salt_t
*salt
= hash_buf
->salt
;
10511 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10517 char *user_pos
= input_buf
;
10519 char *unused_pos
= strchr (user_pos
, ':');
10521 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10523 uint user_len
= unused_pos
- user_pos
;
10525 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10529 char *domain_pos
= strchr (unused_pos
, ':');
10531 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10533 uint unused_len
= domain_pos
- unused_pos
;
10535 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10539 char *srvchall_pos
= strchr (domain_pos
, ':');
10541 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10543 uint domain_len
= srvchall_pos
- domain_pos
;
10545 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10549 char *hash_pos
= strchr (srvchall_pos
, ':');
10551 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10553 uint srvchall_len
= hash_pos
- srvchall_pos
;
10555 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10559 char *clichall_pos
= strchr (hash_pos
, ':');
10561 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10563 uint hash_len
= clichall_pos
- hash_pos
;
10565 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10569 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10571 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10574 * store some data for later use
10577 netntlm
->user_len
= user_len
* 2;
10578 netntlm
->domain_len
= domain_len
* 2;
10579 netntlm
->srvchall_len
= srvchall_len
/ 2;
10580 netntlm
->clichall_len
= clichall_len
/ 2;
10582 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10583 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10586 * handle username and domainname
10589 for (uint i
= 0; i
< user_len
; i
++)
10591 *userdomain_ptr
++ = user_pos
[i
];
10592 *userdomain_ptr
++ = 0;
10595 for (uint i
= 0; i
< domain_len
; i
++)
10597 *userdomain_ptr
++ = domain_pos
[i
];
10598 *userdomain_ptr
++ = 0;
10602 * handle server challenge encoding
10605 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10607 const char p0
= srvchall_pos
[i
+ 0];
10608 const char p1
= srvchall_pos
[i
+ 1];
10610 *chall_ptr
++ = hex_convert (p1
) << 0
10611 | hex_convert (p0
) << 4;
10615 * handle client challenge encoding
10618 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10620 const char p0
= clichall_pos
[i
+ 0];
10621 const char p1
= clichall_pos
[i
+ 1];
10623 *chall_ptr
++ = hex_convert (p1
) << 0
10624 | hex_convert (p0
) << 4;
10631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10633 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10637 salt
->salt_len
= salt_len
;
10639 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10640 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10641 digest
[2] = hex_to_uint (&hash_pos
[16]);
10642 digest
[3] = hex_to_uint (&hash_pos
[24]);
10644 digest
[0] = byte_swap_32 (digest
[0]);
10645 digest
[1] = byte_swap_32 (digest
[1]);
10646 digest
[2] = byte_swap_32 (digest
[2]);
10647 digest
[3] = byte_swap_32 (digest
[3]);
10649 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10651 uint digest_tmp
[2];
10653 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10654 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10656 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10657 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10659 /* special case 2: ESS */
10661 if (srvchall_len
== 48)
10663 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10667 w
[ 0] = netntlm
->chall_buf
[6];
10668 w
[ 1] = netntlm
->chall_buf
[7];
10669 w
[ 2] = netntlm
->chall_buf
[0];
10670 w
[ 3] = netntlm
->chall_buf
[1];
10693 salt
->salt_buf
[0] = dgst
[0];
10694 salt
->salt_buf
[1] = dgst
[1];
10698 /* precompute netntlmv1 exploit start */
10700 for (uint i
= 0; i
< 0x10000; i
++)
10702 uint key_md4
[2] = { i
, 0 };
10703 uint key_des
[2] = { 0, 0 };
10705 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10710 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10712 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10714 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10716 if (data3
[0] != digest_tmp
[0]) continue;
10717 if (data3
[1] != digest_tmp
[1]) continue;
10719 salt
->salt_buf
[2] = i
;
10721 salt
->salt_len
= 24;
10726 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10727 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10729 /* precompute netntlmv1 exploit stop */
10733 IP (digest
[0], digest
[1], tt
);
10734 IP (digest
[2], digest
[3], tt
);
10736 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10737 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10738 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10739 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10741 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10743 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10744 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10746 return (PARSER_OK
);
10749 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10751 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10753 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10755 salt_t
*salt
= hash_buf
->salt
;
10757 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10763 char *user_pos
= input_buf
;
10765 char *unused_pos
= strchr (user_pos
, ':');
10767 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10769 uint user_len
= unused_pos
- user_pos
;
10771 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10775 char *domain_pos
= strchr (unused_pos
, ':');
10777 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10779 uint unused_len
= domain_pos
- unused_pos
;
10781 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10785 char *srvchall_pos
= strchr (domain_pos
, ':');
10787 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10789 uint domain_len
= srvchall_pos
- domain_pos
;
10791 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10795 char *hash_pos
= strchr (srvchall_pos
, ':');
10797 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10799 uint srvchall_len
= hash_pos
- srvchall_pos
;
10801 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10805 char *clichall_pos
= strchr (hash_pos
, ':');
10807 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10809 uint hash_len
= clichall_pos
- hash_pos
;
10811 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10815 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10817 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10819 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10822 * store some data for later use
10825 netntlm
->user_len
= user_len
* 2;
10826 netntlm
->domain_len
= domain_len
* 2;
10827 netntlm
->srvchall_len
= srvchall_len
/ 2;
10828 netntlm
->clichall_len
= clichall_len
/ 2;
10830 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10831 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10834 * handle username and domainname
10837 for (uint i
= 0; i
< user_len
; i
++)
10839 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10840 *userdomain_ptr
++ = 0;
10843 for (uint i
= 0; i
< domain_len
; i
++)
10845 *userdomain_ptr
++ = domain_pos
[i
];
10846 *userdomain_ptr
++ = 0;
10849 *userdomain_ptr
++ = 0x80;
10852 * handle server challenge encoding
10855 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10857 const char p0
= srvchall_pos
[i
+ 0];
10858 const char p1
= srvchall_pos
[i
+ 1];
10860 *chall_ptr
++ = hex_convert (p1
) << 0
10861 | hex_convert (p0
) << 4;
10865 * handle client challenge encoding
10868 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10870 const char p0
= clichall_pos
[i
+ 0];
10871 const char p1
= clichall_pos
[i
+ 1];
10873 *chall_ptr
++ = hex_convert (p1
) << 0
10874 | hex_convert (p0
) << 4;
10877 *chall_ptr
++ = 0x80;
10880 * handle hash itself
10883 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10884 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10885 digest
[2] = hex_to_uint (&hash_pos
[16]);
10886 digest
[3] = hex_to_uint (&hash_pos
[24]);
10888 digest
[0] = byte_swap_32 (digest
[0]);
10889 digest
[1] = byte_swap_32 (digest
[1]);
10890 digest
[2] = byte_swap_32 (digest
[2]);
10891 digest
[3] = byte_swap_32 (digest
[3]);
10894 * reuse challange data as salt_buf, its the buffer that is most likely unique
10897 salt
->salt_buf
[0] = 0;
10898 salt
->salt_buf
[1] = 0;
10899 salt
->salt_buf
[2] = 0;
10900 salt
->salt_buf
[3] = 0;
10901 salt
->salt_buf
[4] = 0;
10902 salt
->salt_buf
[5] = 0;
10903 salt
->salt_buf
[6] = 0;
10904 salt
->salt_buf
[7] = 0;
10908 uptr
= (uint
*) netntlm
->userdomain_buf
;
10910 for (uint i
= 0; i
< 16; i
+= 16)
10912 md5_64 (uptr
, salt
->salt_buf
);
10915 uptr
= (uint
*) netntlm
->chall_buf
;
10917 for (uint i
= 0; i
< 256; i
+= 16)
10919 md5_64 (uptr
, salt
->salt_buf
);
10922 salt
->salt_len
= 16;
10924 return (PARSER_OK
);
10927 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10929 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10931 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10935 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10938 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10940 salt_t
*salt
= hash_buf
->salt
;
10942 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10943 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10944 digest
[2] = hex_to_uint (&input_buf
[16]);
10945 digest
[3] = hex_to_uint (&input_buf
[24]);
10947 digest
[0] = byte_swap_32 (digest
[0]);
10948 digest
[1] = byte_swap_32 (digest
[1]);
10949 digest
[2] = byte_swap_32 (digest
[2]);
10950 digest
[3] = byte_swap_32 (digest
[3]);
10952 digest
[0] -= MD5M_A
;
10953 digest
[1] -= MD5M_B
;
10954 digest
[2] -= MD5M_C
;
10955 digest
[3] -= MD5M_D
;
10957 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10959 uint salt_len
= input_len
- 32 - 1;
10961 char *salt_buf
= input_buf
+ 32 + 1;
10963 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10965 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10967 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10969 salt
->salt_len
= salt_len
;
10971 return (PARSER_OK
);
10974 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10976 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10978 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10982 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
10985 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10987 salt_t
*salt
= hash_buf
->salt
;
10989 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10990 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10991 digest
[2] = hex_to_uint (&input_buf
[16]);
10992 digest
[3] = hex_to_uint (&input_buf
[24]);
10994 digest
[0] = byte_swap_32 (digest
[0]);
10995 digest
[1] = byte_swap_32 (digest
[1]);
10996 digest
[2] = byte_swap_32 (digest
[2]);
10997 digest
[3] = byte_swap_32 (digest
[3]);
10999 digest
[0] -= MD5M_A
;
11000 digest
[1] -= MD5M_B
;
11001 digest
[2] -= MD5M_C
;
11002 digest
[3] -= MD5M_D
;
11004 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11006 uint salt_len
= input_len
- 32 - 1;
11008 char *salt_buf
= input_buf
+ 32 + 1;
11010 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11012 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11014 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11016 salt
->salt_len
= salt_len
;
11018 return (PARSER_OK
);
11021 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11023 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11025 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11027 salt_t
*salt
= hash_buf
->salt
;
11029 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11030 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11031 digest
[2] = hex_to_uint (&input_buf
[16]);
11032 digest
[3] = hex_to_uint (&input_buf
[24]);
11034 digest
[0] = byte_swap_32 (digest
[0]);
11035 digest
[1] = byte_swap_32 (digest
[1]);
11036 digest
[2] = byte_swap_32 (digest
[2]);
11037 digest
[3] = byte_swap_32 (digest
[3]);
11039 digest
[0] -= MD5M_A
;
11040 digest
[1] -= MD5M_B
;
11041 digest
[2] -= MD5M_C
;
11042 digest
[3] -= MD5M_D
;
11045 * This is a virtual salt. While the algorithm is basically not salted
11046 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11047 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11050 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11052 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11054 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11056 salt
->salt_len
= salt_len
;
11058 return (PARSER_OK
);
11061 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11063 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11065 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11069 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11072 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11074 salt_t
*salt
= hash_buf
->salt
;
11076 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11077 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11078 digest
[2] = hex_to_uint (&input_buf
[16]);
11079 digest
[3] = hex_to_uint (&input_buf
[24]);
11081 digest
[0] = byte_swap_32 (digest
[0]);
11082 digest
[1] = byte_swap_32 (digest
[1]);
11083 digest
[2] = byte_swap_32 (digest
[2]);
11084 digest
[3] = byte_swap_32 (digest
[3]);
11086 digest
[0] -= MD5M_A
;
11087 digest
[1] -= MD5M_B
;
11088 digest
[2] -= MD5M_C
;
11089 digest
[3] -= MD5M_D
;
11091 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11093 uint salt_len
= input_len
- 32 - 1;
11095 char *salt_buf
= input_buf
+ 32 + 1;
11097 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11099 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11101 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11103 salt
->salt_len
= salt_len
;
11105 return (PARSER_OK
);
11108 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11110 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11112 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11116 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11119 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11121 salt_t
*salt
= hash_buf
->salt
;
11123 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11124 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11125 digest
[2] = hex_to_uint (&input_buf
[16]);
11126 digest
[3] = hex_to_uint (&input_buf
[24]);
11128 digest
[0] = byte_swap_32 (digest
[0]);
11129 digest
[1] = byte_swap_32 (digest
[1]);
11130 digest
[2] = byte_swap_32 (digest
[2]);
11131 digest
[3] = byte_swap_32 (digest
[3]);
11133 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11135 uint salt_len
= input_len
- 32 - 1;
11137 char *salt_buf
= input_buf
+ 32 + 1;
11139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11141 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11143 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11145 salt
->salt_len
= salt_len
;
11147 return (PARSER_OK
);
11150 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11152 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11154 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11158 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11161 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11163 salt_t
*salt
= hash_buf
->salt
;
11165 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11166 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11167 digest
[2] = hex_to_uint (&input_buf
[16]);
11168 digest
[3] = hex_to_uint (&input_buf
[24]);
11170 digest
[0] = byte_swap_32 (digest
[0]);
11171 digest
[1] = byte_swap_32 (digest
[1]);
11172 digest
[2] = byte_swap_32 (digest
[2]);
11173 digest
[3] = byte_swap_32 (digest
[3]);
11175 digest
[0] -= MD4M_A
;
11176 digest
[1] -= MD4M_B
;
11177 digest
[2] -= MD4M_C
;
11178 digest
[3] -= MD4M_D
;
11180 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11182 uint salt_len
= input_len
- 32 - 1;
11184 char *salt_buf
= input_buf
+ 32 + 1;
11186 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11188 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11190 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11192 salt
->salt_len
= salt_len
;
11194 return (PARSER_OK
);
11197 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11199 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11201 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11205 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11208 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11210 salt_t
*salt
= hash_buf
->salt
;
11212 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11213 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11214 digest
[2] = hex_to_uint (&input_buf
[16]);
11215 digest
[3] = hex_to_uint (&input_buf
[24]);
11217 digest
[0] = byte_swap_32 (digest
[0]);
11218 digest
[1] = byte_swap_32 (digest
[1]);
11219 digest
[2] = byte_swap_32 (digest
[2]);
11220 digest
[3] = byte_swap_32 (digest
[3]);
11222 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11224 uint salt_len
= input_len
- 32 - 1;
11226 char *salt_buf
= input_buf
+ 32 + 1;
11228 uint salt_pc_block
[16];
11230 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11232 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11234 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11236 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11238 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11240 salt_pc_block
[14] = salt_len
* 8;
11242 uint salt_pc_digest
[4];
11244 salt_pc_digest
[0] = MAGIC_A
;
11245 salt_pc_digest
[1] = MAGIC_B
;
11246 salt_pc_digest
[2] = MAGIC_C
;
11247 salt_pc_digest
[3] = MAGIC_D
;
11249 md5_64 (salt_pc_block
, salt_pc_digest
);
11251 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11252 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11253 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11254 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11256 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11258 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11260 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11262 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11263 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11264 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11265 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11267 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11269 return (PARSER_OK
);
11272 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11274 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11276 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11278 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11279 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11280 digest
[2] = hex_to_uint (&input_buf
[16]);
11281 digest
[3] = hex_to_uint (&input_buf
[24]);
11282 digest
[4] = hex_to_uint (&input_buf
[32]);
11284 digest
[0] -= SHA1M_A
;
11285 digest
[1] -= SHA1M_B
;
11286 digest
[2] -= SHA1M_C
;
11287 digest
[3] -= SHA1M_D
;
11288 digest
[4] -= SHA1M_E
;
11290 return (PARSER_OK
);
11293 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11295 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11297 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11299 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11300 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11301 digest
[2] = hex_to_uint (&input_buf
[16]);
11302 digest
[3] = hex_to_uint (&input_buf
[24]);
11303 digest
[4] = hex_to_uint (&input_buf
[32]);
11305 return (PARSER_OK
);
11308 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11310 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11312 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11316 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11319 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11321 salt_t
*salt
= hash_buf
->salt
;
11323 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11324 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11325 digest
[2] = hex_to_uint (&input_buf
[16]);
11326 digest
[3] = hex_to_uint (&input_buf
[24]);
11327 digest
[4] = hex_to_uint (&input_buf
[32]);
11329 digest
[0] -= SHA1M_A
;
11330 digest
[1] -= SHA1M_B
;
11331 digest
[2] -= SHA1M_C
;
11332 digest
[3] -= SHA1M_D
;
11333 digest
[4] -= SHA1M_E
;
11335 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11337 uint salt_len
= input_len
- 40 - 1;
11339 char *salt_buf
= input_buf
+ 40 + 1;
11341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11343 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11345 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11347 salt
->salt_len
= salt_len
;
11349 return (PARSER_OK
);
11352 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11354 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11356 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11358 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11362 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11364 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11366 memcpy (digest
, tmp_buf
, 20);
11368 digest
[0] = byte_swap_32 (digest
[0]);
11369 digest
[1] = byte_swap_32 (digest
[1]);
11370 digest
[2] = byte_swap_32 (digest
[2]);
11371 digest
[3] = byte_swap_32 (digest
[3]);
11372 digest
[4] = byte_swap_32 (digest
[4]);
11374 digest
[0] -= SHA1M_A
;
11375 digest
[1] -= SHA1M_B
;
11376 digest
[2] -= SHA1M_C
;
11377 digest
[3] -= SHA1M_D
;
11378 digest
[4] -= SHA1M_E
;
11380 return (PARSER_OK
);
11383 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11385 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11387 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11389 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11391 salt_t
*salt
= hash_buf
->salt
;
11395 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11397 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11399 memcpy (digest
, tmp_buf
, 20);
11401 salt
->salt_len
= tmp_len
- 20;
11403 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11405 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11407 char *ptr
= (char *) salt
->salt_buf
;
11409 ptr
[salt
->salt_len
] = 0x80;
11412 digest
[0] = byte_swap_32 (digest
[0]);
11413 digest
[1] = byte_swap_32 (digest
[1]);
11414 digest
[2] = byte_swap_32 (digest
[2]);
11415 digest
[3] = byte_swap_32 (digest
[3]);
11416 digest
[4] = byte_swap_32 (digest
[4]);
11418 digest
[0] -= SHA1M_A
;
11419 digest
[1] -= SHA1M_B
;
11420 digest
[2] -= SHA1M_C
;
11421 digest
[3] -= SHA1M_D
;
11422 digest
[4] -= SHA1M_E
;
11424 return (PARSER_OK
);
11427 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11429 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11431 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11433 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11435 salt_t
*salt
= hash_buf
->salt
;
11437 char *salt_buf
= input_buf
+ 6;
11441 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11443 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11445 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11447 salt
->salt_len
= salt_len
;
11449 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11451 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11452 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11453 digest
[2] = hex_to_uint (&hash_pos
[16]);
11454 digest
[3] = hex_to_uint (&hash_pos
[24]);
11455 digest
[4] = hex_to_uint (&hash_pos
[32]);
11457 digest
[0] -= SHA1M_A
;
11458 digest
[1] -= SHA1M_B
;
11459 digest
[2] -= SHA1M_C
;
11460 digest
[3] -= SHA1M_D
;
11461 digest
[4] -= SHA1M_E
;
11463 return (PARSER_OK
);
11466 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11468 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11470 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11472 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11474 salt_t
*salt
= hash_buf
->salt
;
11476 char *salt_buf
= input_buf
+ 6;
11480 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11482 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11484 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11486 salt
->salt_len
= salt_len
;
11488 char *hash_pos
= input_buf
+ 6 + 8;
11490 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11491 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11492 digest
[2] = hex_to_uint (&hash_pos
[16]);
11493 digest
[3] = hex_to_uint (&hash_pos
[24]);
11494 digest
[4] = hex_to_uint (&hash_pos
[32]);
11496 digest
[0] -= SHA1M_A
;
11497 digest
[1] -= SHA1M_B
;
11498 digest
[2] -= SHA1M_C
;
11499 digest
[3] -= SHA1M_D
;
11500 digest
[4] -= SHA1M_E
;
11502 return (PARSER_OK
);
11505 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11507 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11509 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11511 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11513 salt_t
*salt
= hash_buf
->salt
;
11515 char *salt_buf
= input_buf
+ 6;
11519 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11521 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11523 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11525 salt
->salt_len
= salt_len
;
11527 char *hash_pos
= input_buf
+ 6 + 8;
11529 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11530 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11531 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11532 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11533 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11534 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11535 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11536 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11538 digest
[0] -= SHA512M_A
;
11539 digest
[1] -= SHA512M_B
;
11540 digest
[2] -= SHA512M_C
;
11541 digest
[3] -= SHA512M_D
;
11542 digest
[4] -= SHA512M_E
;
11543 digest
[5] -= SHA512M_F
;
11544 digest
[6] -= SHA512M_G
;
11545 digest
[7] -= SHA512M_H
;
11547 return (PARSER_OK
);
11550 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11552 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11554 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11558 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11561 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11563 salt_t
*salt
= hash_buf
->salt
;
11565 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11566 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11570 digest
[0] = byte_swap_32 (digest
[0]);
11571 digest
[1] = byte_swap_32 (digest
[1]);
11573 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11575 uint salt_len
= input_len
- 16 - 1;
11577 char *salt_buf
= input_buf
+ 16 + 1;
11579 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11581 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11583 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11585 salt
->salt_len
= salt_len
;
11587 return (PARSER_OK
);
11590 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11592 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11594 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11596 salt_t
*salt
= hash_buf
->salt
;
11598 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11599 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11600 digest
[2] = hex_to_uint (&input_buf
[16]);
11601 digest
[3] = hex_to_uint (&input_buf
[24]);
11602 digest
[4] = hex_to_uint (&input_buf
[32]);
11604 digest
[0] -= SHA1M_A
;
11605 digest
[1] -= SHA1M_B
;
11606 digest
[2] -= SHA1M_C
;
11607 digest
[3] -= SHA1M_D
;
11608 digest
[4] -= SHA1M_E
;
11610 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11612 uint salt_len
= input_len
- 40 - 1;
11614 char *salt_buf
= input_buf
+ 40 + 1;
11616 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11618 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11620 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11622 salt
->salt_len
= salt_len
;
11624 return (PARSER_OK
);
11627 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11629 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11631 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11633 salt_t
*salt
= hash_buf
->salt
;
11635 char *hash_pos
= input_buf
;
11637 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11638 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11639 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11640 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11641 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11642 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11643 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11644 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11645 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11646 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11647 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11648 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11649 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11650 digest
[13] = hex_to_uint (&hash_pos
[104]);
11651 digest
[14] = hex_to_uint (&hash_pos
[112]);
11652 digest
[15] = hex_to_uint (&hash_pos
[120]);
11654 char *salt_pos
= input_buf
+ 128;
11656 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11657 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11658 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11659 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11661 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11662 salt
->salt_len
= 16;
11664 return (PARSER_OK
);
11667 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11669 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11671 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11673 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11674 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11675 digest
[2] = hex_to_uint (&input_buf
[16]);
11676 digest
[3] = hex_to_uint (&input_buf
[24]);
11677 digest
[4] = hex_to_uint (&input_buf
[32]);
11678 digest
[5] = hex_to_uint (&input_buf
[40]);
11679 digest
[6] = hex_to_uint (&input_buf
[48]);
11680 digest
[7] = hex_to_uint (&input_buf
[56]);
11682 digest
[0] -= SHA256M_A
;
11683 digest
[1] -= SHA256M_B
;
11684 digest
[2] -= SHA256M_C
;
11685 digest
[3] -= SHA256M_D
;
11686 digest
[4] -= SHA256M_E
;
11687 digest
[5] -= SHA256M_F
;
11688 digest
[6] -= SHA256M_G
;
11689 digest
[7] -= SHA256M_H
;
11691 return (PARSER_OK
);
11694 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11696 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11698 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11702 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11705 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11707 salt_t
*salt
= hash_buf
->salt
;
11709 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11710 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11711 digest
[2] = hex_to_uint (&input_buf
[16]);
11712 digest
[3] = hex_to_uint (&input_buf
[24]);
11713 digest
[4] = hex_to_uint (&input_buf
[32]);
11714 digest
[5] = hex_to_uint (&input_buf
[40]);
11715 digest
[6] = hex_to_uint (&input_buf
[48]);
11716 digest
[7] = hex_to_uint (&input_buf
[56]);
11718 digest
[0] -= SHA256M_A
;
11719 digest
[1] -= SHA256M_B
;
11720 digest
[2] -= SHA256M_C
;
11721 digest
[3] -= SHA256M_D
;
11722 digest
[4] -= SHA256M_E
;
11723 digest
[5] -= SHA256M_F
;
11724 digest
[6] -= SHA256M_G
;
11725 digest
[7] -= SHA256M_H
;
11727 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11729 uint salt_len
= input_len
- 64 - 1;
11731 char *salt_buf
= input_buf
+ 64 + 1;
11733 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11735 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11737 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11739 salt
->salt_len
= salt_len
;
11741 return (PARSER_OK
);
11744 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11746 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11748 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11750 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11751 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11752 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11753 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11754 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11755 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11759 digest
[0] -= SHA384M_A
;
11760 digest
[1] -= SHA384M_B
;
11761 digest
[2] -= SHA384M_C
;
11762 digest
[3] -= SHA384M_D
;
11763 digest
[4] -= SHA384M_E
;
11764 digest
[5] -= SHA384M_F
;
11768 return (PARSER_OK
);
11771 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11773 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11775 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11777 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11778 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11779 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11780 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11781 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11782 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11783 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11784 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11786 digest
[0] -= SHA512M_A
;
11787 digest
[1] -= SHA512M_B
;
11788 digest
[2] -= SHA512M_C
;
11789 digest
[3] -= SHA512M_D
;
11790 digest
[4] -= SHA512M_E
;
11791 digest
[5] -= SHA512M_F
;
11792 digest
[6] -= SHA512M_G
;
11793 digest
[7] -= SHA512M_H
;
11795 return (PARSER_OK
);
11798 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11800 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11802 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11806 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11809 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11811 salt_t
*salt
= hash_buf
->salt
;
11813 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11814 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11815 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11816 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11817 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11818 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11819 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11820 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11822 digest
[0] -= SHA512M_A
;
11823 digest
[1] -= SHA512M_B
;
11824 digest
[2] -= SHA512M_C
;
11825 digest
[3] -= SHA512M_D
;
11826 digest
[4] -= SHA512M_E
;
11827 digest
[5] -= SHA512M_F
;
11828 digest
[6] -= SHA512M_G
;
11829 digest
[7] -= SHA512M_H
;
11831 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11833 uint salt_len
= input_len
- 128 - 1;
11835 char *salt_buf
= input_buf
+ 128 + 1;
11837 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11839 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11841 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11843 salt
->salt_len
= salt_len
;
11845 return (PARSER_OK
);
11848 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11850 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11852 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11854 salt_t
*salt
= hash_buf
->salt
;
11856 char *salt_pos
= input_buf
+ 3;
11858 uint iterations_len
= 0;
11860 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11864 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11866 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11867 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11871 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11875 iterations_len
+= 8;
11879 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11882 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11884 char *hash_pos
= strchr (salt_pos
, '$');
11886 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11888 uint salt_len
= hash_pos
- salt_pos
;
11890 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11892 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11894 salt
->salt_len
= salt_len
;
11898 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11900 return (PARSER_OK
);
11903 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11905 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11907 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11909 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11911 salt_t
*salt
= hash_buf
->salt
;
11913 uint keccak_mdlen
= input_len
/ 2;
11915 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11917 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11919 digest
[i
] = byte_swap_64 (digest
[i
]);
11922 salt
->keccak_mdlen
= keccak_mdlen
;
11924 return (PARSER_OK
);
11927 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11929 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11931 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11933 salt_t
*salt
= hash_buf
->salt
;
11935 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11938 * Parse that strange long line
11945 in_off
[0] = strtok (input_buf
, ":");
11947 in_len
[0] = strlen (in_off
[0]);
11951 for (i
= 1; i
< 9; i
++)
11953 in_off
[i
] = strtok (NULL
, ":");
11955 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11957 in_len
[i
] = strlen (in_off
[i
]);
11962 ptr
= (char *) ikepsk
->msg_buf
;
11964 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11965 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11966 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11967 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11968 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11969 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11973 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11975 ptr
= (char *) ikepsk
->nr_buf
;
11977 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11978 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11982 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
11985 * Store to database
11990 digest
[0] = hex_to_uint (&ptr
[ 0]);
11991 digest
[1] = hex_to_uint (&ptr
[ 8]);
11992 digest
[2] = hex_to_uint (&ptr
[16]);
11993 digest
[3] = hex_to_uint (&ptr
[24]);
11995 digest
[0] = byte_swap_32 (digest
[0]);
11996 digest
[1] = byte_swap_32 (digest
[1]);
11997 digest
[2] = byte_swap_32 (digest
[2]);
11998 digest
[3] = byte_swap_32 (digest
[3]);
12000 salt
->salt_len
= 32;
12002 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12003 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12004 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12005 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12006 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12007 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12008 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12009 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12011 return (PARSER_OK
);
12014 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12016 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12018 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12020 salt_t
*salt
= hash_buf
->salt
;
12022 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12025 * Parse that strange long line
12032 in_off
[0] = strtok (input_buf
, ":");
12034 in_len
[0] = strlen (in_off
[0]);
12038 for (i
= 1; i
< 9; i
++)
12040 in_off
[i
] = strtok (NULL
, ":");
12042 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12044 in_len
[i
] = strlen (in_off
[i
]);
12049 ptr
= (char *) ikepsk
->msg_buf
;
12051 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12052 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12053 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12054 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12055 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12056 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12060 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12062 ptr
= (char *) ikepsk
->nr_buf
;
12064 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12065 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12069 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12072 * Store to database
12077 digest
[0] = hex_to_uint (&ptr
[ 0]);
12078 digest
[1] = hex_to_uint (&ptr
[ 8]);
12079 digest
[2] = hex_to_uint (&ptr
[16]);
12080 digest
[3] = hex_to_uint (&ptr
[24]);
12081 digest
[4] = hex_to_uint (&ptr
[32]);
12083 salt
->salt_len
= 32;
12085 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12086 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12087 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12088 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12089 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12090 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12091 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12092 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12094 return (PARSER_OK
);
12097 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12099 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12101 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12103 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12104 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12105 digest
[2] = hex_to_uint (&input_buf
[16]);
12106 digest
[3] = hex_to_uint (&input_buf
[24]);
12107 digest
[4] = hex_to_uint (&input_buf
[32]);
12109 digest
[0] = byte_swap_32 (digest
[0]);
12110 digest
[1] = byte_swap_32 (digest
[1]);
12111 digest
[2] = byte_swap_32 (digest
[2]);
12112 digest
[3] = byte_swap_32 (digest
[3]);
12113 digest
[4] = byte_swap_32 (digest
[4]);
12115 return (PARSER_OK
);
12118 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12120 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12122 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12124 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12125 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12126 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12127 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12128 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12129 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12130 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12131 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12132 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12133 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12134 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12135 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12136 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12137 digest
[13] = hex_to_uint (&input_buf
[104]);
12138 digest
[14] = hex_to_uint (&input_buf
[112]);
12139 digest
[15] = hex_to_uint (&input_buf
[120]);
12141 return (PARSER_OK
);
12144 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12146 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12148 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12150 salt_t
*salt
= hash_buf
->salt
;
12152 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12153 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12154 digest
[2] = hex_to_uint (&input_buf
[16]);
12155 digest
[3] = hex_to_uint (&input_buf
[24]);
12156 digest
[4] = hex_to_uint (&input_buf
[32]);
12158 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12160 uint salt_len
= input_len
- 40 - 1;
12162 char *salt_buf
= input_buf
+ 40 + 1;
12164 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12166 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12168 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12170 salt
->salt_len
= salt_len
;
12172 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12174 return (PARSER_OK
);
12177 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12179 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12181 salt_t
*salt
= hash_buf
->salt
;
12183 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12185 if (input_len
== 0)
12187 log_error ("TrueCrypt container not specified");
12192 FILE *fp
= fopen (input_buf
, "rb");
12196 log_error ("%s: %s", input_buf
, strerror (errno
));
12203 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12207 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12209 memcpy (tc
->salt_buf
, buf
, 64);
12211 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12213 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12215 salt
->salt_len
= 4;
12217 salt
->salt_iter
= 1000 - 1;
12219 digest
[0] = tc
->data_buf
[0];
12221 return (PARSER_OK
);
12224 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12226 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12228 salt_t
*salt
= hash_buf
->salt
;
12230 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12232 if (input_len
== 0)
12234 log_error ("TrueCrypt container not specified");
12239 FILE *fp
= fopen (input_buf
, "rb");
12243 log_error ("%s: %s", input_buf
, strerror (errno
));
12250 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12254 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12256 memcpy (tc
->salt_buf
, buf
, 64);
12258 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12260 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12262 salt
->salt_len
= 4;
12264 salt
->salt_iter
= 2000 - 1;
12266 digest
[0] = tc
->data_buf
[0];
12268 return (PARSER_OK
);
12271 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12273 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12275 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12277 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12279 salt_t
*salt
= hash_buf
->salt
;
12281 char *salt_pos
= input_buf
+ 6;
12283 char *hash_pos
= strchr (salt_pos
, '$');
12285 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12287 uint salt_len
= hash_pos
- salt_pos
;
12289 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12291 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12293 salt
->salt_len
= salt_len
;
12295 salt
->salt_iter
= 1000;
12299 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12301 return (PARSER_OK
);
12304 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12306 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12308 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12310 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12312 salt_t
*salt
= hash_buf
->salt
;
12314 char *iter_pos
= input_buf
+ 7;
12316 char *salt_pos
= strchr (iter_pos
, '$');
12318 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12322 char *hash_pos
= strchr (salt_pos
, '$');
12324 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12326 uint salt_len
= hash_pos
- salt_pos
;
12328 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12330 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12332 salt
->salt_len
= salt_len
;
12334 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12336 salt
->salt_sign
[0] = atoi (salt_iter
);
12338 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12342 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12344 digest
[0] = byte_swap_32 (digest
[0]);
12345 digest
[1] = byte_swap_32 (digest
[1]);
12346 digest
[2] = byte_swap_32 (digest
[2]);
12347 digest
[3] = byte_swap_32 (digest
[3]);
12348 digest
[4] = byte_swap_32 (digest
[4]);
12350 return (PARSER_OK
);
12353 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12355 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12357 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12359 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12361 salt_t
*salt
= hash_buf
->salt
;
12363 char *iter_pos
= input_buf
+ 9;
12365 char *salt_pos
= strchr (iter_pos
, '$');
12367 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12371 char *hash_pos
= strchr (salt_pos
, '$');
12373 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12375 uint salt_len
= hash_pos
- salt_pos
;
12377 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12379 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12381 salt
->salt_len
= salt_len
;
12383 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12385 salt
->salt_sign
[0] = atoi (salt_iter
);
12387 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12391 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12393 digest
[0] = byte_swap_32 (digest
[0]);
12394 digest
[1] = byte_swap_32 (digest
[1]);
12395 digest
[2] = byte_swap_32 (digest
[2]);
12396 digest
[3] = byte_swap_32 (digest
[3]);
12397 digest
[4] = byte_swap_32 (digest
[4]);
12398 digest
[5] = byte_swap_32 (digest
[5]);
12399 digest
[6] = byte_swap_32 (digest
[6]);
12400 digest
[7] = byte_swap_32 (digest
[7]);
12402 return (PARSER_OK
);
12405 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12407 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12409 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12411 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12413 salt_t
*salt
= hash_buf
->salt
;
12415 char *iter_pos
= input_buf
+ 9;
12417 char *salt_pos
= strchr (iter_pos
, '$');
12419 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12423 char *hash_pos
= strchr (salt_pos
, '$');
12425 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12427 uint salt_len
= hash_pos
- salt_pos
;
12429 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12431 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12433 salt
->salt_len
= salt_len
;
12435 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12437 salt
->salt_sign
[0] = atoi (salt_iter
);
12439 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12443 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12445 digest
[0] = byte_swap_64 (digest
[0]);
12446 digest
[1] = byte_swap_64 (digest
[1]);
12447 digest
[2] = byte_swap_64 (digest
[2]);
12448 digest
[3] = byte_swap_64 (digest
[3]);
12449 digest
[4] = byte_swap_64 (digest
[4]);
12450 digest
[5] = byte_swap_64 (digest
[5]);
12451 digest
[6] = byte_swap_64 (digest
[6]);
12452 digest
[7] = byte_swap_64 (digest
[7]);
12454 return (PARSER_OK
);
12457 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12459 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12461 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12463 salt_t
*salt
= hash_buf
->salt
;
12465 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12471 char *iterations_pos
= input_buf
;
12473 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12475 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12477 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12479 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12483 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12485 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12487 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12489 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12491 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12493 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12498 * pbkdf2 iterations
12501 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12504 * handle salt encoding
12507 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12509 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12511 const char p0
= saltbuf_pos
[i
+ 0];
12512 const char p1
= saltbuf_pos
[i
+ 1];
12514 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12515 | hex_convert (p0
) << 4;
12518 salt
->salt_len
= saltbuf_len
/ 2;
12521 * handle cipher encoding
12524 uint
*tmp
= (uint
*) mymalloc (32);
12526 char *cipherbuf_ptr
= (char *) tmp
;
12528 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12530 const char p0
= cipherbuf_pos
[i
+ 0];
12531 const char p1
= cipherbuf_pos
[i
+ 1];
12533 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12534 | hex_convert (p0
) << 4;
12537 // iv is stored at salt_buf 4 (length 16)
12538 // data is stored at salt_buf 8 (length 16)
12540 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12541 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12542 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12543 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12545 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12546 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12547 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12548 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12552 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12554 const char p0
= cipherbuf_pos
[j
+ 0];
12555 const char p1
= cipherbuf_pos
[j
+ 1];
12557 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12558 | hex_convert (p0
) << 4;
12565 digest
[0] = 0x10101010;
12566 digest
[1] = 0x10101010;
12567 digest
[2] = 0x10101010;
12568 digest
[3] = 0x10101010;
12570 return (PARSER_OK
);
12573 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12575 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12577 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12579 salt_t
*salt
= hash_buf
->salt
;
12581 char *hashbuf_pos
= input_buf
;
12583 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12585 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12587 uint hash_len
= iterations_pos
- hashbuf_pos
;
12589 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12593 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12595 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12597 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12601 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12603 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12605 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12607 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12609 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12611 salt
->salt_len
= salt_len
;
12613 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12615 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12616 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12617 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12618 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12620 return (PARSER_OK
);
12623 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12625 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12627 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12629 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12630 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12631 digest
[2] = hex_to_uint (&input_buf
[16]);
12632 digest
[3] = hex_to_uint (&input_buf
[24]);
12633 digest
[4] = hex_to_uint (&input_buf
[32]);
12634 digest
[5] = hex_to_uint (&input_buf
[40]);
12635 digest
[6] = hex_to_uint (&input_buf
[48]);
12636 digest
[7] = hex_to_uint (&input_buf
[56]);
12638 digest
[0] = byte_swap_32 (digest
[0]);
12639 digest
[1] = byte_swap_32 (digest
[1]);
12640 digest
[2] = byte_swap_32 (digest
[2]);
12641 digest
[3] = byte_swap_32 (digest
[3]);
12642 digest
[4] = byte_swap_32 (digest
[4]);
12643 digest
[5] = byte_swap_32 (digest
[5]);
12644 digest
[6] = byte_swap_32 (digest
[6]);
12645 digest
[7] = byte_swap_32 (digest
[7]);
12647 return (PARSER_OK
);
12650 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12652 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12654 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12656 salt_t
*salt
= hash_buf
->salt
;
12658 char *salt_pos
= input_buf
+ 3;
12660 uint iterations_len
= 0;
12662 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12666 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12668 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12669 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12673 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12677 iterations_len
+= 8;
12681 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12684 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12686 char *hash_pos
= strchr (salt_pos
, '$');
12688 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12690 uint salt_len
= hash_pos
- salt_pos
;
12692 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12694 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12696 salt
->salt_len
= salt_len
;
12700 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12702 return (PARSER_OK
);
12705 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12707 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12709 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12711 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12713 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12715 salt_t
*salt
= hash_buf
->salt
;
12717 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12719 char *iter_pos
= input_buf
+ 4;
12721 char *salt_pos
= strchr (iter_pos
, '$');
12723 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12727 char *hash_pos
= strchr (salt_pos
, '$');
12729 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12731 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12735 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12736 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12737 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12738 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12739 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12740 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12741 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12742 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12744 uint salt_len
= hash_pos
- salt_pos
- 1;
12746 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12748 salt
->salt_len
= salt_len
/ 2;
12750 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12751 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12752 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12753 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12754 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12755 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12756 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12757 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12759 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12760 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12761 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12762 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12763 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12764 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12765 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12766 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12767 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12768 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12770 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12772 salt
->salt_iter
= atoi (iter_pos
) - 1;
12774 return (PARSER_OK
);
12777 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12779 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12781 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12783 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12785 salt_t
*salt
= hash_buf
->salt
;
12787 char *salt_pos
= input_buf
+ 14;
12789 char *hash_pos
= strchr (salt_pos
, '*');
12791 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12795 uint salt_len
= hash_pos
- salt_pos
- 1;
12797 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12799 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12801 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12803 salt
->salt_len
= salt_len
;
12805 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12807 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12809 memcpy (digest
, tmp_buf
, 32);
12811 digest
[0] = byte_swap_32 (digest
[0]);
12812 digest
[1] = byte_swap_32 (digest
[1]);
12813 digest
[2] = byte_swap_32 (digest
[2]);
12814 digest
[3] = byte_swap_32 (digest
[3]);
12815 digest
[4] = byte_swap_32 (digest
[4]);
12816 digest
[5] = byte_swap_32 (digest
[5]);
12817 digest
[6] = byte_swap_32 (digest
[6]);
12818 digest
[7] = byte_swap_32 (digest
[7]);
12820 digest
[0] -= SHA256M_A
;
12821 digest
[1] -= SHA256M_B
;
12822 digest
[2] -= SHA256M_C
;
12823 digest
[3] -= SHA256M_D
;
12824 digest
[4] -= SHA256M_E
;
12825 digest
[5] -= SHA256M_F
;
12826 digest
[6] -= SHA256M_G
;
12827 digest
[7] -= SHA256M_H
;
12829 return (PARSER_OK
);
12832 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12834 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12836 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12838 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12840 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12842 salt_t
*salt
= hash_buf
->salt
;
12844 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12846 char *iter_pos
= input_buf
+ 19;
12848 char *salt_pos
= strchr (iter_pos
, '.');
12850 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12854 char *hash_pos
= strchr (salt_pos
, '.');
12856 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12858 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12862 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12863 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12864 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12865 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12866 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12867 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12868 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12869 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12871 uint salt_len
= hash_pos
- salt_pos
- 1;
12875 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12879 for (i
= 0; i
< salt_len
; i
++)
12881 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12884 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12885 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12887 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12889 salt
->salt_len
= salt_len
;
12891 salt
->salt_iter
= atoi (iter_pos
) - 1;
12893 return (PARSER_OK
);
12896 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12898 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12900 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12902 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12904 salt_t
*salt
= hash_buf
->salt
;
12908 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12910 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12912 memcpy (digest
, tmp_buf
, 64);
12914 digest
[0] = byte_swap_64 (digest
[0]);
12915 digest
[1] = byte_swap_64 (digest
[1]);
12916 digest
[2] = byte_swap_64 (digest
[2]);
12917 digest
[3] = byte_swap_64 (digest
[3]);
12918 digest
[4] = byte_swap_64 (digest
[4]);
12919 digest
[5] = byte_swap_64 (digest
[5]);
12920 digest
[6] = byte_swap_64 (digest
[6]);
12921 digest
[7] = byte_swap_64 (digest
[7]);
12923 digest
[0] -= SHA512M_A
;
12924 digest
[1] -= SHA512M_B
;
12925 digest
[2] -= SHA512M_C
;
12926 digest
[3] -= SHA512M_D
;
12927 digest
[4] -= SHA512M_E
;
12928 digest
[5] -= SHA512M_F
;
12929 digest
[6] -= SHA512M_G
;
12930 digest
[7] -= SHA512M_H
;
12932 salt
->salt_len
= tmp_len
- 64;
12934 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12936 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12938 char *ptr
= (char *) salt
->salt_buf
;
12940 ptr
[salt
->salt_len
] = 0x80;
12943 return (PARSER_OK
);
12946 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12948 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12950 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12954 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12957 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12959 salt_t
*salt
= hash_buf
->salt
;
12961 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12962 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12963 digest
[2] = hex_to_uint (&input_buf
[16]);
12964 digest
[3] = hex_to_uint (&input_buf
[24]);
12966 digest
[0] = byte_swap_32 (digest
[0]);
12967 digest
[1] = byte_swap_32 (digest
[1]);
12968 digest
[2] = byte_swap_32 (digest
[2]);
12969 digest
[3] = byte_swap_32 (digest
[3]);
12971 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12973 uint salt_len
= input_len
- 32 - 1;
12975 char *salt_buf
= input_buf
+ 32 + 1;
12977 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12979 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12981 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12983 salt
->salt_len
= salt_len
;
12985 return (PARSER_OK
);
12988 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12990 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12992 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
12996 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
12999 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13001 salt_t
*salt
= hash_buf
->salt
;
13003 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13004 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13005 digest
[2] = hex_to_uint (&input_buf
[16]);
13006 digest
[3] = hex_to_uint (&input_buf
[24]);
13007 digest
[4] = hex_to_uint (&input_buf
[32]);
13009 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13011 uint salt_len
= input_len
- 40 - 1;
13013 char *salt_buf
= input_buf
+ 40 + 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 hmacsha256_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_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13034 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13037 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13039 salt_t
*salt
= hash_buf
->salt
;
13041 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13042 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13043 digest
[2] = hex_to_uint (&input_buf
[16]);
13044 digest
[3] = hex_to_uint (&input_buf
[24]);
13045 digest
[4] = hex_to_uint (&input_buf
[32]);
13046 digest
[5] = hex_to_uint (&input_buf
[40]);
13047 digest
[6] = hex_to_uint (&input_buf
[48]);
13048 digest
[7] = hex_to_uint (&input_buf
[56]);
13050 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13052 uint salt_len
= input_len
- 64 - 1;
13054 char *salt_buf
= input_buf
+ 64 + 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 hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13069 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13071 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13075 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13078 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13080 salt_t
*salt
= hash_buf
->salt
;
13082 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13083 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13084 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13085 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13086 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13087 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13088 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13089 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13091 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13093 uint salt_len
= input_len
- 128 - 1;
13095 char *salt_buf
= input_buf
+ 128 + 1;
13097 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13099 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13101 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13103 salt
->salt_len
= salt_len
;
13105 return (PARSER_OK
);
13108 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13110 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13112 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13114 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13116 salt_t
*salt
= hash_buf
->salt
;
13118 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13124 char *user_pos
= input_buf
+ 10 + 1;
13126 char *realm_pos
= strchr (user_pos
, '$');
13128 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13130 uint user_len
= realm_pos
- user_pos
;
13132 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13136 char *salt_pos
= strchr (realm_pos
, '$');
13138 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13140 uint realm_len
= salt_pos
- realm_pos
;
13142 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13146 char *data_pos
= strchr (salt_pos
, '$');
13148 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13150 uint salt_len
= data_pos
- salt_pos
;
13152 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13156 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13158 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13164 memcpy (krb5pa
->user
, user_pos
, user_len
);
13165 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13166 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13168 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13170 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13172 const char p0
= data_pos
[i
+ 0];
13173 const char p1
= data_pos
[i
+ 1];
13175 *timestamp_ptr
++ = hex_convert (p1
) << 0
13176 | hex_convert (p0
) << 4;
13179 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13181 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13183 const char p0
= data_pos
[i
+ 0];
13184 const char p1
= data_pos
[i
+ 1];
13186 *checksum_ptr
++ = hex_convert (p1
) << 0
13187 | hex_convert (p0
) << 4;
13191 * copy some data to generic buffers to make sorting happy
13194 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13195 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13196 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13197 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13198 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13199 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13200 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13201 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13202 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13204 salt
->salt_len
= 36;
13206 digest
[0] = krb5pa
->checksum
[0];
13207 digest
[1] = krb5pa
->checksum
[1];
13208 digest
[2] = krb5pa
->checksum
[2];
13209 digest
[3] = krb5pa
->checksum
[3];
13211 return (PARSER_OK
);
13214 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13216 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13218 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13220 salt_t
*salt
= hash_buf
->salt
;
13226 char *salt_pos
= input_buf
;
13228 char *hash_pos
= strchr (salt_pos
, '$');
13230 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13232 uint salt_len
= hash_pos
- salt_pos
;
13234 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13238 uint hash_len
= input_len
- 1 - salt_len
;
13240 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13248 for (uint i
= 0; i
< salt_len
; i
++)
13250 if (salt_pos
[i
] == ' ') continue;
13255 // SAP user names cannot be longer than 12 characters
13256 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13258 // SAP user name cannot start with ! or ?
13259 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13265 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13267 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13269 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13271 salt
->salt_len
= salt_len
;
13273 digest
[0] = hex_to_uint (&hash_pos
[0]);
13274 digest
[1] = hex_to_uint (&hash_pos
[8]);
13278 digest
[0] = byte_swap_32 (digest
[0]);
13279 digest
[1] = byte_swap_32 (digest
[1]);
13281 return (PARSER_OK
);
13284 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13286 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13288 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13290 salt_t
*salt
= hash_buf
->salt
;
13296 char *salt_pos
= input_buf
;
13298 char *hash_pos
= strchr (salt_pos
, '$');
13300 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13302 uint salt_len
= hash_pos
- salt_pos
;
13304 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13308 uint hash_len
= input_len
- 1 - salt_len
;
13310 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13318 for (uint i
= 0; i
< salt_len
; i
++)
13320 if (salt_pos
[i
] == ' ') continue;
13325 // SAP user names cannot be longer than 12 characters
13326 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13327 // so far nobody complained so we stay with this because it helps in optimization
13328 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13330 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13332 // SAP user name cannot start with ! or ?
13333 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13339 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13341 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13343 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13345 salt
->salt_len
= salt_len
;
13347 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13348 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13349 digest
[2] = hex_to_uint (&hash_pos
[16]);
13350 digest
[3] = hex_to_uint (&hash_pos
[24]);
13351 digest
[4] = hex_to_uint (&hash_pos
[32]);
13353 return (PARSER_OK
);
13356 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13358 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13360 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13362 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13364 salt_t
*salt
= hash_buf
->salt
;
13366 char *iter_pos
= input_buf
+ 3;
13368 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13370 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13372 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13374 salt
->salt_iter
= salt_iter
;
13376 char *salt_pos
= iter_pos
+ 1;
13380 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13382 salt
->salt_len
= salt_len
;
13384 char *hash_pos
= salt_pos
+ salt_len
;
13386 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13390 char *tmp
= (char *) salt
->salt_buf_pc
;
13392 tmp
[0] = hash_pos
[42];
13396 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13397 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13398 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13399 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13405 return (PARSER_OK
);
13408 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13410 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13412 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13414 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13416 salt_t
*salt
= hash_buf
->salt
;
13418 char *salt_buf
= input_buf
+ 6;
13420 uint salt_len
= 16;
13422 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13424 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13426 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13428 salt
->salt_len
= salt_len
;
13430 char *hash_pos
= input_buf
+ 6 + 16;
13432 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13433 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13434 digest
[2] = hex_to_uint (&hash_pos
[16]);
13435 digest
[3] = hex_to_uint (&hash_pos
[24]);
13436 digest
[4] = hex_to_uint (&hash_pos
[32]);
13437 digest
[5] = hex_to_uint (&hash_pos
[40]);
13438 digest
[6] = hex_to_uint (&hash_pos
[48]);
13439 digest
[7] = hex_to_uint (&hash_pos
[56]);
13441 return (PARSER_OK
);
13444 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13446 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13448 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13450 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13451 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13455 return (PARSER_OK
);
13458 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13460 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13462 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13464 salt_t
*salt
= hash_buf
->salt
;
13466 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13468 char *saltbuf_pos
= input_buf
;
13470 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13472 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13474 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13476 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13477 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13479 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13483 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13485 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13487 char *salt_ptr
= (char *) saltbuf_pos
;
13488 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13493 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13495 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13498 rakp_ptr
[j
] = 0x80;
13500 rakp
->salt_len
= j
;
13502 for (i
= 0; i
< 64; i
++)
13504 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13507 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13508 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13509 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13510 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13511 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13512 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13513 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13514 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13516 salt
->salt_len
= 32; // muss min. 32 haben
13518 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13519 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13520 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13521 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13522 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13524 return (PARSER_OK
);
13527 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13529 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13531 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13533 salt_t
*salt
= hash_buf
->salt
;
13535 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13537 char *salt_pos
= input_buf
+ 1;
13539 memcpy (salt
->salt_buf
, salt_pos
, 8);
13541 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13542 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13544 salt
->salt_len
= 8;
13546 char *hash_pos
= salt_pos
+ 8;
13548 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13549 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13550 digest
[2] = hex_to_uint (&hash_pos
[16]);
13551 digest
[3] = hex_to_uint (&hash_pos
[24]);
13552 digest
[4] = hex_to_uint (&hash_pos
[32]);
13554 digest
[0] -= SHA1M_A
;
13555 digest
[1] -= SHA1M_B
;
13556 digest
[2] -= SHA1M_C
;
13557 digest
[3] -= SHA1M_D
;
13558 digest
[4] -= SHA1M_E
;
13560 return (PARSER_OK
);
13563 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13565 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13567 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13569 salt_t
*salt
= hash_buf
->salt
;
13571 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13572 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13573 digest
[2] = hex_to_uint (&input_buf
[16]);
13574 digest
[3] = hex_to_uint (&input_buf
[24]);
13576 digest
[0] = byte_swap_32 (digest
[0]);
13577 digest
[1] = byte_swap_32 (digest
[1]);
13578 digest
[2] = byte_swap_32 (digest
[2]);
13579 digest
[3] = byte_swap_32 (digest
[3]);
13581 digest
[0] -= MD5M_A
;
13582 digest
[1] -= MD5M_B
;
13583 digest
[2] -= MD5M_C
;
13584 digest
[3] -= MD5M_D
;
13586 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13588 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13590 uint32_t *salt_buf
= salt
->salt_buf
;
13592 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13593 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13594 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13595 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13597 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13598 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13599 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13600 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13602 salt
->salt_len
= 16 + 1;
13604 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13606 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13608 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13610 return (PARSER_OK
);
13613 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13615 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13617 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13619 salt_t
*salt
= hash_buf
->salt
;
13621 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13627 char *hashbuf_pos
= input_buf
;
13629 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13631 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13633 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13635 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13639 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13641 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13643 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13645 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13649 char *databuf_pos
= strchr (iteration_pos
, ':');
13651 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13653 const uint iteration_len
= databuf_pos
- iteration_pos
;
13655 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13656 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13658 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13660 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13661 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13667 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13668 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13669 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13670 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13671 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13672 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13673 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13674 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13678 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13680 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13682 const char p0
= saltbuf_pos
[i
+ 0];
13683 const char p1
= saltbuf_pos
[i
+ 1];
13685 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13686 | hex_convert (p0
) << 4;
13689 salt
->salt_buf
[4] = 0x01000000;
13690 salt
->salt_buf
[5] = 0x80;
13692 salt
->salt_len
= saltbuf_len
/ 2;
13696 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13700 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13702 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13704 const char p0
= databuf_pos
[i
+ 0];
13705 const char p1
= databuf_pos
[i
+ 1];
13707 *databuf_ptr
++ = hex_convert (p1
) << 0
13708 | hex_convert (p0
) << 4;
13711 *databuf_ptr
++ = 0x80;
13713 for (uint i
= 0; i
< 512; i
++)
13715 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13718 cloudkey
->data_len
= databuf_len
/ 2;
13720 return (PARSER_OK
);
13723 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13725 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13727 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13729 salt_t
*salt
= hash_buf
->salt
;
13735 char *hashbuf_pos
= input_buf
;
13737 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13739 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13741 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13743 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13747 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13749 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13751 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13753 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13755 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13759 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13761 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13763 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13765 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13767 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13771 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13773 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13774 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13776 // ok, the plan for this algorithm is the following:
13777 // we have 2 salts here, the domain-name and a random salt
13778 // while both are used in the initial transformation,
13779 // only the random salt is used in the following iterations
13780 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13781 // and one that includes only the real salt (stored into salt_buf[]).
13782 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13784 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13786 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13788 memcpy (digest
, tmp_buf
, 20);
13790 digest
[0] = byte_swap_32 (digest
[0]);
13791 digest
[1] = byte_swap_32 (digest
[1]);
13792 digest
[2] = byte_swap_32 (digest
[2]);
13793 digest
[3] = byte_swap_32 (digest
[3]);
13794 digest
[4] = byte_swap_32 (digest
[4]);
13798 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13800 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13802 char *len_ptr
= NULL
;
13804 for (uint i
= 0; i
< domainbuf_len
; i
++)
13806 if (salt_buf_pc_ptr
[i
] == '.')
13808 len_ptr
= &salt_buf_pc_ptr
[i
];
13818 salt
->salt_buf_pc
[7] = domainbuf_len
;
13822 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13824 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13826 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13828 salt
->salt_len
= salt_len
;
13832 salt
->salt_iter
= atoi (iteration_pos
);
13834 return (PARSER_OK
);
13837 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13839 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13841 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13843 salt_t
*salt
= hash_buf
->salt
;
13845 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13846 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13847 digest
[2] = hex_to_uint (&input_buf
[16]);
13848 digest
[3] = hex_to_uint (&input_buf
[24]);
13849 digest
[4] = hex_to_uint (&input_buf
[32]);
13851 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13853 uint salt_len
= input_len
- 40 - 1;
13855 char *salt_buf
= input_buf
+ 40 + 1;
13857 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13859 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13861 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13863 salt
->salt_len
= salt_len
;
13865 return (PARSER_OK
);
13868 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13870 const uint8_t ascii_to_ebcdic
[] =
13872 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13873 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13874 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13875 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13876 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13877 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13878 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13879 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13880 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13881 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13882 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13883 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13884 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13885 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13886 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13887 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13890 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13892 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13894 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13896 salt_t
*salt
= hash_buf
->salt
;
13898 char *salt_pos
= input_buf
+ 6 + 1;
13900 char *digest_pos
= strchr (salt_pos
, '*');
13902 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13904 uint salt_len
= digest_pos
- salt_pos
;
13906 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13908 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13910 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13914 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13915 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13921 salt
->salt_len
= salt_len
;
13923 for (uint i
= 0; i
< salt_len
; i
++)
13925 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13927 for (uint i
= salt_len
; i
< 8; i
++)
13929 salt_buf_pc_ptr
[i
] = 0x40;
13934 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13936 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13937 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13939 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13940 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13942 digest
[0] = byte_swap_32 (digest
[0]);
13943 digest
[1] = byte_swap_32 (digest
[1]);
13945 IP (digest
[0], digest
[1], tt
);
13947 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13948 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13952 return (PARSER_OK
);
13955 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13957 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13959 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13961 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13962 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13963 digest
[2] = hex_to_uint (&input_buf
[16]);
13964 digest
[3] = hex_to_uint (&input_buf
[24]);
13966 digest
[0] = byte_swap_32 (digest
[0]);
13967 digest
[1] = byte_swap_32 (digest
[1]);
13968 digest
[2] = byte_swap_32 (digest
[2]);
13969 digest
[3] = byte_swap_32 (digest
[3]);
13971 return (PARSER_OK
);
13974 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13976 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13978 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13980 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13982 salt_t
*salt
= hash_buf
->salt
;
13986 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13988 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13990 tmp_buf
[3] += -4; // dont ask!
13992 memcpy (salt
->salt_buf
, tmp_buf
, 5);
13994 salt
->salt_len
= 5;
13996 memcpy (digest
, tmp_buf
+ 5, 9);
13998 // yes, only 9 byte are needed to crack, but 10 to display
14000 salt
->salt_buf_pc
[7] = input_buf
[20];
14002 return (PARSER_OK
);
14005 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14007 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14009 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14011 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14013 salt_t
*salt
= hash_buf
->salt
;
14017 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14019 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14021 tmp_buf
[3] += -4; // dont ask!
14025 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14027 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)
14031 char tmp_iter_buf
[11];
14033 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14035 tmp_iter_buf
[10] = 0;
14037 salt
->salt_iter
= atoi (tmp_iter_buf
);
14039 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14041 return (PARSER_SALT_ITERATION
);
14044 salt
->salt_iter
--; // first round in init
14046 // 2 additional bytes for display only
14048 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14049 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14053 memcpy (digest
, tmp_buf
+ 28, 8);
14055 digest
[0] = byte_swap_32 (digest
[0]);
14056 digest
[1] = byte_swap_32 (digest
[1]);
14060 return (PARSER_OK
);
14063 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14065 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14067 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14069 salt_t
*salt
= hash_buf
->salt
;
14071 char *salt_buf_pos
= input_buf
;
14073 char *hash_buf_pos
= salt_buf_pos
+ 6;
14075 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14076 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14077 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14078 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14079 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14080 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14081 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14082 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14084 digest
[0] -= SHA256M_A
;
14085 digest
[1] -= SHA256M_B
;
14086 digest
[2] -= SHA256M_C
;
14087 digest
[3] -= SHA256M_D
;
14088 digest
[4] -= SHA256M_E
;
14089 digest
[5] -= SHA256M_F
;
14090 digest
[6] -= SHA256M_G
;
14091 digest
[7] -= SHA256M_H
;
14093 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14095 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14097 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14099 salt
->salt_len
= salt_len
;
14101 return (PARSER_OK
);
14104 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14106 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14108 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14110 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14112 salt_t
*salt
= hash_buf
->salt
;
14114 char *salt_buf
= input_buf
+ 6;
14116 char *digest_buf
= strchr (salt_buf
, '$');
14118 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14120 uint salt_len
= digest_buf
- salt_buf
;
14122 digest_buf
++; // skip the '$' symbol
14124 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14126 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14128 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14130 salt
->salt_len
= salt_len
;
14132 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14133 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14134 digest
[2] = hex_to_uint (&digest_buf
[16]);
14135 digest
[3] = hex_to_uint (&digest_buf
[24]);
14137 digest
[0] = byte_swap_32 (digest
[0]);
14138 digest
[1] = byte_swap_32 (digest
[1]);
14139 digest
[2] = byte_swap_32 (digest
[2]);
14140 digest
[3] = byte_swap_32 (digest
[3]);
14142 digest
[0] -= MD5M_A
;
14143 digest
[1] -= MD5M_B
;
14144 digest
[2] -= MD5M_C
;
14145 digest
[3] -= MD5M_D
;
14147 return (PARSER_OK
);
14150 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14152 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14154 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14156 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14158 salt_t
*salt
= hash_buf
->salt
;
14160 char *salt_buf
= input_buf
+ 3;
14162 char *digest_buf
= strchr (salt_buf
, '$');
14164 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14166 uint salt_len
= digest_buf
- salt_buf
;
14168 digest_buf
++; // skip the '$' symbol
14170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14176 salt_buf_ptr
[salt_len
] = 0x2d;
14178 salt
->salt_len
= salt_len
+ 1;
14180 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14181 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14182 digest
[2] = hex_to_uint (&digest_buf
[16]);
14183 digest
[3] = hex_to_uint (&digest_buf
[24]);
14185 digest
[0] = byte_swap_32 (digest
[0]);
14186 digest
[1] = byte_swap_32 (digest
[1]);
14187 digest
[2] = byte_swap_32 (digest
[2]);
14188 digest
[3] = byte_swap_32 (digest
[3]);
14190 digest
[0] -= MD5M_A
;
14191 digest
[1] -= MD5M_B
;
14192 digest
[2] -= MD5M_C
;
14193 digest
[3] -= MD5M_D
;
14195 return (PARSER_OK
);
14198 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14200 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14202 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14206 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14208 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14210 memcpy (digest
, tmp_buf
, 20);
14212 digest
[0] = byte_swap_32 (digest
[0]);
14213 digest
[1] = byte_swap_32 (digest
[1]);
14214 digest
[2] = byte_swap_32 (digest
[2]);
14215 digest
[3] = byte_swap_32 (digest
[3]);
14216 digest
[4] = byte_swap_32 (digest
[4]);
14218 digest
[0] -= SHA1M_A
;
14219 digest
[1] -= SHA1M_B
;
14220 digest
[2] -= SHA1M_C
;
14221 digest
[3] -= SHA1M_D
;
14222 digest
[4] -= SHA1M_E
;
14224 return (PARSER_OK
);
14227 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14229 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14231 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14233 salt_t
*salt
= hash_buf
->salt
;
14235 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14236 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14237 digest
[2] = hex_to_uint (&input_buf
[16]);
14238 digest
[3] = hex_to_uint (&input_buf
[24]);
14240 digest
[0] = byte_swap_32 (digest
[0]);
14241 digest
[1] = byte_swap_32 (digest
[1]);
14242 digest
[2] = byte_swap_32 (digest
[2]);
14243 digest
[3] = byte_swap_32 (digest
[3]);
14245 digest
[0] -= MD5M_A
;
14246 digest
[1] -= MD5M_B
;
14247 digest
[2] -= MD5M_C
;
14248 digest
[3] -= MD5M_D
;
14250 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14252 uint salt_len
= input_len
- 32 - 1;
14254 char *salt_buf
= input_buf
+ 32 + 1;
14256 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14258 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14260 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14263 * add static "salt" part
14266 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14270 salt
->salt_len
= salt_len
;
14272 return (PARSER_OK
);
14275 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14277 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14279 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14281 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14283 salt_t
*salt
= hash_buf
->salt
;
14285 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14291 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14293 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14295 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14297 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14299 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14303 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14305 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14307 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14309 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14313 char *keybuf_pos
= strchr (keylen_pos
, '$');
14315 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14317 uint keylen_len
= keybuf_pos
- keylen_pos
;
14319 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14323 char *databuf_pos
= strchr (keybuf_pos
, '$');
14325 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14327 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14329 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14333 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14335 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14341 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14342 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14343 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14344 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14346 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14347 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14348 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14349 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14351 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14352 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14353 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14354 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14356 salt
->salt_len
= 16;
14357 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14359 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14361 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14364 return (PARSER_OK
);
14367 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14369 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14371 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14373 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14375 salt_t
*salt
= hash_buf
->salt
;
14381 // first is the N salt parameter
14383 char *N_pos
= input_buf
+ 6;
14385 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14389 salt
->scrypt_N
= atoi (N_pos
);
14393 char *r_pos
= strchr (N_pos
, ':');
14395 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14399 salt
->scrypt_r
= atoi (r_pos
);
14403 char *p_pos
= strchr (r_pos
, ':');
14405 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14409 salt
->scrypt_p
= atoi (p_pos
);
14413 char *saltbuf_pos
= strchr (p_pos
, ':');
14415 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14419 char *hash_pos
= strchr (saltbuf_pos
, ':');
14421 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14429 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14431 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14433 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14435 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14437 salt
->salt_len
= tmp_len
;
14438 salt
->salt_iter
= 1;
14440 // digest - base64 decode
14442 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14444 tmp_len
= input_len
- (hash_pos
- input_buf
);
14446 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14448 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14450 memcpy (digest
, tmp_buf
, 32);
14452 return (PARSER_OK
);
14455 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14457 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14459 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14461 salt_t
*salt
= hash_buf
->salt
;
14467 char decrypted
[76]; // iv + hash
14469 juniper_decrypt_hash (input_buf
, decrypted
);
14471 char *md5crypt_hash
= decrypted
+ 12;
14473 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14475 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14477 char *salt_pos
= md5crypt_hash
+ 3;
14479 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14481 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14483 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14487 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14489 return (PARSER_OK
);
14492 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14494 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14496 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14498 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14500 salt_t
*salt
= hash_buf
->salt
;
14502 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14508 // first is *raw* salt
14510 char *salt_pos
= input_buf
+ 3;
14512 char *hash_pos
= strchr (salt_pos
, '$');
14514 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14516 uint salt_len
= hash_pos
- salt_pos
;
14518 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14522 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14524 memcpy (salt_buf_ptr
, salt_pos
, 14);
14526 salt_buf_ptr
[17] = 0x01;
14527 salt_buf_ptr
[18] = 0x80;
14529 // add some stuff to normal salt to make sorted happy
14531 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14532 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14533 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14534 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14536 salt
->salt_len
= salt_len
;
14537 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14539 // base64 decode hash
14543 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14545 uint hash_len
= input_len
- 3 - salt_len
- 1;
14547 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14549 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14551 memcpy (digest
, tmp_buf
, 32);
14553 digest
[0] = byte_swap_32 (digest
[0]);
14554 digest
[1] = byte_swap_32 (digest
[1]);
14555 digest
[2] = byte_swap_32 (digest
[2]);
14556 digest
[3] = byte_swap_32 (digest
[3]);
14557 digest
[4] = byte_swap_32 (digest
[4]);
14558 digest
[5] = byte_swap_32 (digest
[5]);
14559 digest
[6] = byte_swap_32 (digest
[6]);
14560 digest
[7] = byte_swap_32 (digest
[7]);
14562 return (PARSER_OK
);
14565 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14567 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14569 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14571 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14573 salt_t
*salt
= hash_buf
->salt
;
14579 // first is *raw* salt
14581 char *salt_pos
= input_buf
+ 3;
14583 char *hash_pos
= strchr (salt_pos
, '$');
14585 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14587 uint salt_len
= hash_pos
- salt_pos
;
14589 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14591 salt
->salt_len
= salt_len
;
14594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14596 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14597 salt_buf_ptr
[salt_len
] = 0;
14599 // base64 decode hash
14603 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14605 uint hash_len
= input_len
- 3 - salt_len
- 1;
14607 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14609 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14611 memcpy (digest
, tmp_buf
, 32);
14614 salt
->scrypt_N
= 16384;
14615 salt
->scrypt_r
= 1;
14616 salt
->scrypt_p
= 1;
14617 salt
->salt_iter
= 1;
14619 return (PARSER_OK
);
14622 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14624 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14626 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14628 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14630 salt_t
*salt
= hash_buf
->salt
;
14632 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14638 char *version_pos
= input_buf
+ 8 + 1;
14640 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14642 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14644 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14646 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14648 verifierHashSize_pos
++;
14650 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14652 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14654 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14656 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14660 char *saltSize_pos
= strchr (keySize_pos
, '*');
14662 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14664 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14666 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14670 char *osalt_pos
= strchr (saltSize_pos
, '*');
14672 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14674 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14676 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14680 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14682 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14684 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14686 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14688 encryptedVerifier_pos
++;
14690 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14692 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14694 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14696 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14698 encryptedVerifierHash_pos
++;
14700 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;
14702 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14704 const uint version
= atoi (version_pos
);
14706 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14708 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14710 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14712 const uint keySize
= atoi (keySize_pos
);
14714 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14716 office2007
->keySize
= keySize
;
14718 const uint saltSize
= atoi (saltSize_pos
);
14720 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14726 salt
->salt_len
= 16;
14727 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14729 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14730 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14731 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14732 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14738 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14739 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14740 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14741 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14743 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14744 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14745 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14746 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14747 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14753 digest
[0] = office2007
->encryptedVerifierHash
[0];
14754 digest
[1] = office2007
->encryptedVerifierHash
[1];
14755 digest
[2] = office2007
->encryptedVerifierHash
[2];
14756 digest
[3] = office2007
->encryptedVerifierHash
[3];
14758 return (PARSER_OK
);
14761 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14763 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14765 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14767 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14769 salt_t
*salt
= hash_buf
->salt
;
14771 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14777 char *version_pos
= input_buf
+ 8 + 1;
14779 char *spinCount_pos
= strchr (version_pos
, '*');
14781 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14783 uint32_t version_len
= spinCount_pos
- version_pos
;
14785 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14789 char *keySize_pos
= strchr (spinCount_pos
, '*');
14791 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14793 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14795 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14799 char *saltSize_pos
= strchr (keySize_pos
, '*');
14801 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14803 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14805 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14809 char *osalt_pos
= strchr (saltSize_pos
, '*');
14811 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14813 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14815 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14819 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14821 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14823 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14825 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14827 encryptedVerifier_pos
++;
14829 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14831 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14833 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14835 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14837 encryptedVerifierHash_pos
++;
14839 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;
14841 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14843 const uint version
= atoi (version_pos
);
14845 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14847 const uint spinCount
= atoi (spinCount_pos
);
14849 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14851 const uint keySize
= atoi (keySize_pos
);
14853 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14855 const uint saltSize
= atoi (saltSize_pos
);
14857 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14863 salt
->salt_len
= 16;
14864 salt
->salt_iter
= spinCount
;
14866 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14867 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14868 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14869 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14875 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14876 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14877 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14878 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14880 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14881 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14882 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14883 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14884 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14885 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14886 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14887 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14893 digest
[0] = office2010
->encryptedVerifierHash
[0];
14894 digest
[1] = office2010
->encryptedVerifierHash
[1];
14895 digest
[2] = office2010
->encryptedVerifierHash
[2];
14896 digest
[3] = office2010
->encryptedVerifierHash
[3];
14898 return (PARSER_OK
);
14901 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14903 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14905 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14907 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14909 salt_t
*salt
= hash_buf
->salt
;
14911 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14917 char *version_pos
= input_buf
+ 8 + 1;
14919 char *spinCount_pos
= strchr (version_pos
, '*');
14921 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14923 uint32_t version_len
= spinCount_pos
- version_pos
;
14925 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14929 char *keySize_pos
= strchr (spinCount_pos
, '*');
14931 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14933 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14935 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14939 char *saltSize_pos
= strchr (keySize_pos
, '*');
14941 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14943 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14945 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14949 char *osalt_pos
= strchr (saltSize_pos
, '*');
14951 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14953 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14955 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14959 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14961 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14963 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14965 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14967 encryptedVerifier_pos
++;
14969 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14971 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14973 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14975 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14977 encryptedVerifierHash_pos
++;
14979 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;
14981 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14983 const uint version
= atoi (version_pos
);
14985 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14987 const uint spinCount
= atoi (spinCount_pos
);
14989 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14991 const uint keySize
= atoi (keySize_pos
);
14993 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
14995 const uint saltSize
= atoi (saltSize_pos
);
14997 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15003 salt
->salt_len
= 16;
15004 salt
->salt_iter
= spinCount
;
15006 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15007 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15008 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15009 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15015 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15016 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15017 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15018 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15020 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15021 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15022 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15023 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15024 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15025 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15026 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15027 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15033 digest
[0] = office2013
->encryptedVerifierHash
[0];
15034 digest
[1] = office2013
->encryptedVerifierHash
[1];
15035 digest
[2] = office2013
->encryptedVerifierHash
[2];
15036 digest
[3] = office2013
->encryptedVerifierHash
[3];
15038 return (PARSER_OK
);
15041 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15043 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15045 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15047 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15049 salt_t
*salt
= hash_buf
->salt
;
15051 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15057 char *version_pos
= input_buf
+ 11;
15059 char *osalt_pos
= strchr (version_pos
, '*');
15061 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15063 uint32_t version_len
= osalt_pos
- version_pos
;
15065 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15069 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15071 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15073 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15075 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15077 encryptedVerifier_pos
++;
15079 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15081 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15083 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15085 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15087 encryptedVerifierHash_pos
++;
15089 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15091 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15093 const uint version
= *version_pos
- 0x30;
15095 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15101 oldoffice01
->version
= version
;
15103 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15104 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15105 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15106 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15108 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15109 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15110 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15111 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15113 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15114 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15115 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15116 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15118 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15119 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15120 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15121 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15127 salt
->salt_len
= 16;
15129 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15130 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15131 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15132 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15134 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15135 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15136 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15137 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15139 // this is a workaround as office produces multiple documents with the same salt
15141 salt
->salt_len
+= 32;
15143 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15144 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15145 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15146 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15147 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15148 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15149 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15150 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15156 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15157 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15158 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15159 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15161 return (PARSER_OK
);
15164 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15166 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15169 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15171 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15173 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15175 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15177 salt_t
*salt
= hash_buf
->salt
;
15179 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15185 char *version_pos
= input_buf
+ 11;
15187 char *osalt_pos
= strchr (version_pos
, '*');
15189 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15191 uint32_t version_len
= osalt_pos
- version_pos
;
15193 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15197 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15199 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15201 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15203 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15205 encryptedVerifier_pos
++;
15207 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15209 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15211 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15213 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15215 encryptedVerifierHash_pos
++;
15217 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15219 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15221 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15223 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15227 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15229 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15231 const uint version
= *version_pos
- 0x30;
15233 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15239 oldoffice01
->version
= version
;
15241 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15242 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15243 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15244 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15246 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15247 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15248 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15249 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15251 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15252 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15253 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15254 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15256 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15257 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15258 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15259 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15261 oldoffice01
->rc4key
[1] = 0;
15262 oldoffice01
->rc4key
[0] = 0;
15264 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15265 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15266 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15267 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15268 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15269 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15270 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15271 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15272 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15273 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15275 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15276 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15282 salt
->salt_len
= 16;
15284 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15285 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15286 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15287 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15289 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15290 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15291 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15292 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15294 // this is a workaround as office produces multiple documents with the same salt
15296 salt
->salt_len
+= 32;
15298 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15299 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15300 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15301 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15302 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15303 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15304 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15305 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15311 digest
[0] = oldoffice01
->rc4key
[0];
15312 digest
[1] = oldoffice01
->rc4key
[1];
15316 return (PARSER_OK
);
15319 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15321 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15323 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15325 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15327 salt_t
*salt
= hash_buf
->salt
;
15329 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15335 char *version_pos
= input_buf
+ 11;
15337 char *osalt_pos
= strchr (version_pos
, '*');
15339 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15341 uint32_t version_len
= osalt_pos
- version_pos
;
15343 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15347 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15349 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15351 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15353 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15355 encryptedVerifier_pos
++;
15357 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15359 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15361 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15363 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15365 encryptedVerifierHash_pos
++;
15367 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15369 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15371 const uint version
= *version_pos
- 0x30;
15373 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15379 oldoffice34
->version
= version
;
15381 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15382 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15383 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15384 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15386 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15387 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15388 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15389 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15391 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15392 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15393 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15394 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15395 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15397 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15398 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15399 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15400 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15401 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15407 salt
->salt_len
= 16;
15409 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15410 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15411 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15412 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15414 // this is a workaround as office produces multiple documents with the same salt
15416 salt
->salt_len
+= 32;
15418 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15419 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15420 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15421 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15422 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15423 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15424 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15425 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15431 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15432 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15433 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15434 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15436 return (PARSER_OK
);
15439 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15441 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15443 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15446 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15448 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15450 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15452 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15454 salt_t
*salt
= hash_buf
->salt
;
15456 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15462 char *version_pos
= input_buf
+ 11;
15464 char *osalt_pos
= strchr (version_pos
, '*');
15466 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15468 uint32_t version_len
= osalt_pos
- version_pos
;
15470 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15474 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15476 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15478 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15480 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15482 encryptedVerifier_pos
++;
15484 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15486 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15488 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15490 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15492 encryptedVerifierHash_pos
++;
15494 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15496 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15498 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15500 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15504 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15506 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15508 const uint version
= *version_pos
- 0x30;
15510 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15516 oldoffice34
->version
= version
;
15518 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15519 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15520 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15521 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15523 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15524 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15525 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15526 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15528 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15529 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15530 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15531 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15532 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15534 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15535 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15536 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15537 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15538 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15540 oldoffice34
->rc4key
[1] = 0;
15541 oldoffice34
->rc4key
[0] = 0;
15543 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15544 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15545 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15546 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15547 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15548 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15549 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15550 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15551 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15552 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15554 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15555 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15561 salt
->salt_len
= 16;
15563 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15564 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15565 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15566 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15568 // this is a workaround as office produces multiple documents with the same salt
15570 salt
->salt_len
+= 32;
15572 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15573 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15574 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15575 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15576 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15577 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15578 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15579 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15585 digest
[0] = oldoffice34
->rc4key
[0];
15586 digest
[1] = oldoffice34
->rc4key
[1];
15590 return (PARSER_OK
);
15593 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15595 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15597 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15599 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15600 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15601 digest
[2] = hex_to_uint (&input_buf
[16]);
15602 digest
[3] = hex_to_uint (&input_buf
[24]);
15604 digest
[0] = byte_swap_32 (digest
[0]);
15605 digest
[1] = byte_swap_32 (digest
[1]);
15606 digest
[2] = byte_swap_32 (digest
[2]);
15607 digest
[3] = byte_swap_32 (digest
[3]);
15609 return (PARSER_OK
);
15612 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15614 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15616 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15618 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15620 salt_t
*salt
= hash_buf
->salt
;
15622 char *signature_pos
= input_buf
;
15624 char *salt_pos
= strchr (signature_pos
, '$');
15626 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15628 uint32_t signature_len
= salt_pos
- signature_pos
;
15630 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15634 char *hash_pos
= strchr (salt_pos
, '$');
15636 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15638 uint32_t salt_len
= hash_pos
- salt_pos
;
15640 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15644 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15646 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15648 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15649 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15650 digest
[2] = hex_to_uint (&hash_pos
[16]);
15651 digest
[3] = hex_to_uint (&hash_pos
[24]);
15652 digest
[4] = hex_to_uint (&hash_pos
[32]);
15654 digest
[0] -= SHA1M_A
;
15655 digest
[1] -= SHA1M_B
;
15656 digest
[2] -= SHA1M_C
;
15657 digest
[3] -= SHA1M_D
;
15658 digest
[4] -= SHA1M_E
;
15660 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15662 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15664 salt
->salt_len
= salt_len
;
15666 return (PARSER_OK
);
15669 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15671 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15673 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15675 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15677 salt_t
*salt
= hash_buf
->salt
;
15679 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15685 char *iter_pos
= input_buf
+ 14;
15687 const int iter
= atoi (iter_pos
);
15689 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15691 salt
->salt_iter
= iter
- 1;
15693 char *salt_pos
= strchr (iter_pos
, '$');
15695 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15699 char *hash_pos
= strchr (salt_pos
, '$');
15701 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15703 const uint salt_len
= hash_pos
- salt_pos
;
15707 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15709 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15711 salt
->salt_len
= salt_len
;
15713 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15714 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15716 // add some stuff to normal salt to make sorted happy
15718 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15719 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15720 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15721 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15722 salt
->salt_buf
[4] = salt
->salt_iter
;
15724 // base64 decode hash
15728 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15730 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15732 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15734 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15736 memcpy (digest
, tmp_buf
, 32);
15738 digest
[0] = byte_swap_32 (digest
[0]);
15739 digest
[1] = byte_swap_32 (digest
[1]);
15740 digest
[2] = byte_swap_32 (digest
[2]);
15741 digest
[3] = byte_swap_32 (digest
[3]);
15742 digest
[4] = byte_swap_32 (digest
[4]);
15743 digest
[5] = byte_swap_32 (digest
[5]);
15744 digest
[6] = byte_swap_32 (digest
[6]);
15745 digest
[7] = byte_swap_32 (digest
[7]);
15747 return (PARSER_OK
);
15750 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15752 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15754 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15756 salt_t
*salt
= hash_buf
->salt
;
15758 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15759 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15763 digest
[0] = byte_swap_32 (digest
[0]);
15764 digest
[1] = byte_swap_32 (digest
[1]);
15766 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15768 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15770 char iter_c
= input_buf
[17];
15771 char iter_d
= input_buf
[19];
15773 // atm only defaults, let's see if there's more request
15774 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15775 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15777 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15779 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15780 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15781 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15782 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15784 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15785 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15786 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15787 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15789 salt
->salt_len
= 16;
15791 return (PARSER_OK
);
15794 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15796 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15798 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15800 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15802 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15804 salt_t
*salt
= hash_buf
->salt
;
15806 char *salt_pos
= input_buf
+ 10;
15808 char *hash_pos
= strchr (salt_pos
, '$');
15810 uint salt_len
= hash_pos
- salt_pos
;
15812 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15816 uint hash_len
= input_len
- 10 - salt_len
- 1;
15818 // base64 decode salt
15822 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15824 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15826 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15828 tmp_buf
[salt_len
] = 0x80;
15830 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15832 salt
->salt_len
= salt_len
;
15834 // base64 decode salt
15836 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15838 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15840 uint user_len
= hash_len
- 32;
15842 char *tmp_hash
= tmp_buf
+ user_len
;
15844 user_len
--; // skip the trailing space
15846 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15847 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15848 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15849 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15851 digest
[0] = byte_swap_32 (digest
[0]);
15852 digest
[1] = byte_swap_32 (digest
[1]);
15853 digest
[2] = byte_swap_32 (digest
[2]);
15854 digest
[3] = byte_swap_32 (digest
[3]);
15856 // store username for host only (output hash if cracked)
15858 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15859 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15861 return (PARSER_OK
);
15864 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15866 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15868 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15870 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15872 salt_t
*salt
= hash_buf
->salt
;
15874 char *iter_pos
= input_buf
+ 10;
15876 uint32_t iter
= atoi (iter_pos
);
15880 return (PARSER_SALT_ITERATION
);
15883 iter
--; // first iteration is special
15885 salt
->salt_iter
= iter
;
15887 char *base64_pos
= strchr (iter_pos
, '}');
15889 if (base64_pos
== NULL
)
15891 return (PARSER_SIGNATURE_UNMATCHED
);
15896 // base64 decode salt
15898 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15902 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15904 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15906 if (decoded_len
< 24)
15908 return (PARSER_SALT_LENGTH
);
15913 uint salt_len
= decoded_len
- 20;
15915 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15916 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15918 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15920 salt
->salt_len
= salt_len
;
15924 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15926 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15927 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15928 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15929 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15930 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15932 return (PARSER_OK
);
15935 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15937 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15939 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15941 salt_t
*salt
= hash_buf
->salt
;
15943 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15944 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15945 digest
[2] = hex_to_uint (&input_buf
[16]);
15946 digest
[3] = hex_to_uint (&input_buf
[24]);
15947 digest
[4] = hex_to_uint (&input_buf
[32]);
15949 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15951 uint salt_len
= input_len
- 40 - 1;
15953 char *salt_buf
= input_buf
+ 40 + 1;
15955 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15957 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15959 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15961 salt
->salt_len
= salt_len
;
15963 return (PARSER_OK
);
15966 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15968 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15970 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15972 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15974 salt_t
*salt
= hash_buf
->salt
;
15976 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15982 char *V_pos
= input_buf
+ 5;
15984 char *R_pos
= strchr (V_pos
, '*');
15986 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15988 uint32_t V_len
= R_pos
- V_pos
;
15992 char *bits_pos
= strchr (R_pos
, '*');
15994 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15996 uint32_t R_len
= bits_pos
- R_pos
;
16000 char *P_pos
= strchr (bits_pos
, '*');
16002 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16004 uint32_t bits_len
= P_pos
- bits_pos
;
16008 char *enc_md_pos
= strchr (P_pos
, '*');
16010 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16012 uint32_t P_len
= enc_md_pos
- P_pos
;
16016 char *id_len_pos
= strchr (enc_md_pos
, '*');
16018 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16020 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16024 char *id_buf_pos
= strchr (id_len_pos
, '*');
16026 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16028 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16032 char *u_len_pos
= strchr (id_buf_pos
, '*');
16034 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16036 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16038 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16042 char *u_buf_pos
= strchr (u_len_pos
, '*');
16044 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16046 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16050 char *o_len_pos
= strchr (u_buf_pos
, '*');
16052 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16054 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16056 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16060 char *o_buf_pos
= strchr (o_len_pos
, '*');
16062 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16064 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16068 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;
16070 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16074 const int V
= atoi (V_pos
);
16075 const int R
= atoi (R_pos
);
16076 const int P
= atoi (P_pos
);
16078 if (V
!= 1) return (PARSER_SALT_VALUE
);
16079 if (R
!= 2) return (PARSER_SALT_VALUE
);
16081 const int enc_md
= atoi (enc_md_pos
);
16083 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16085 const int id_len
= atoi (id_len_pos
);
16086 const int u_len
= atoi (u_len_pos
);
16087 const int o_len
= atoi (o_len_pos
);
16089 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16090 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16091 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16093 const int bits
= atoi (bits_pos
);
16095 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16097 // copy data to esalt
16103 pdf
->enc_md
= enc_md
;
16105 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16106 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16107 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16108 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16109 pdf
->id_len
= id_len
;
16111 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16112 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16113 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16114 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16115 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16116 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16117 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16118 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16119 pdf
->u_len
= u_len
;
16121 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16122 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16123 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16124 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16125 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16126 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16127 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16128 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16129 pdf
->o_len
= o_len
;
16131 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16132 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16133 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16134 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16136 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16137 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16138 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16139 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16140 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16141 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16142 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16143 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16145 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16146 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16147 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16148 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16149 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16150 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16151 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16152 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16154 // we use ID for salt, maybe needs to change, we will see...
16156 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16157 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16158 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16159 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16160 salt
->salt_len
= pdf
->id_len
;
16162 digest
[0] = pdf
->u_buf
[0];
16163 digest
[1] = pdf
->u_buf
[1];
16164 digest
[2] = pdf
->u_buf
[2];
16165 digest
[3] = pdf
->u_buf
[3];
16167 return (PARSER_OK
);
16170 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16172 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16175 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16177 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16179 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16181 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16183 salt_t
*salt
= hash_buf
->salt
;
16185 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16191 char *V_pos
= input_buf
+ 5;
16193 char *R_pos
= strchr (V_pos
, '*');
16195 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16197 uint32_t V_len
= R_pos
- V_pos
;
16201 char *bits_pos
= strchr (R_pos
, '*');
16203 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16205 uint32_t R_len
= bits_pos
- R_pos
;
16209 char *P_pos
= strchr (bits_pos
, '*');
16211 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16213 uint32_t bits_len
= P_pos
- bits_pos
;
16217 char *enc_md_pos
= strchr (P_pos
, '*');
16219 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16221 uint32_t P_len
= enc_md_pos
- P_pos
;
16225 char *id_len_pos
= strchr (enc_md_pos
, '*');
16227 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16229 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16233 char *id_buf_pos
= strchr (id_len_pos
, '*');
16235 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16237 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16241 char *u_len_pos
= strchr (id_buf_pos
, '*');
16243 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16245 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16247 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16251 char *u_buf_pos
= strchr (u_len_pos
, '*');
16253 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16255 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16259 char *o_len_pos
= strchr (u_buf_pos
, '*');
16261 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16263 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16265 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16269 char *o_buf_pos
= strchr (o_len_pos
, '*');
16271 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16273 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16277 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16279 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16281 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16283 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16287 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;
16289 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16293 const int V
= atoi (V_pos
);
16294 const int R
= atoi (R_pos
);
16295 const int P
= atoi (P_pos
);
16297 if (V
!= 1) return (PARSER_SALT_VALUE
);
16298 if (R
!= 2) return (PARSER_SALT_VALUE
);
16300 const int enc_md
= atoi (enc_md_pos
);
16302 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16304 const int id_len
= atoi (id_len_pos
);
16305 const int u_len
= atoi (u_len_pos
);
16306 const int o_len
= atoi (o_len_pos
);
16308 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16309 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16310 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16312 const int bits
= atoi (bits_pos
);
16314 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16316 // copy data to esalt
16322 pdf
->enc_md
= enc_md
;
16324 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16325 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16326 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16327 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16328 pdf
->id_len
= id_len
;
16330 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16331 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16332 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16333 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16334 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16335 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16336 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16337 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16338 pdf
->u_len
= u_len
;
16340 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16341 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16342 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16343 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16344 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16345 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16346 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16347 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16348 pdf
->o_len
= o_len
;
16350 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16351 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16352 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16353 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16355 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16356 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16357 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16358 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16359 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16360 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16361 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16362 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16364 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16365 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16366 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16367 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16368 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16369 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16370 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16371 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16373 pdf
->rc4key
[1] = 0;
16374 pdf
->rc4key
[0] = 0;
16376 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16377 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16378 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16379 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16380 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16381 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16382 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16383 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16384 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16385 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16387 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16388 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16390 // we use ID for salt, maybe needs to change, we will see...
16392 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16393 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16394 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16395 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16396 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16397 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16398 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16399 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16400 salt
->salt_len
= pdf
->id_len
+ 16;
16402 digest
[0] = pdf
->rc4key
[0];
16403 digest
[1] = pdf
->rc4key
[1];
16407 return (PARSER_OK
);
16410 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16412 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16414 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16416 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16418 salt_t
*salt
= hash_buf
->salt
;
16420 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16426 char *V_pos
= input_buf
+ 5;
16428 char *R_pos
= strchr (V_pos
, '*');
16430 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16432 uint32_t V_len
= R_pos
- V_pos
;
16436 char *bits_pos
= strchr (R_pos
, '*');
16438 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16440 uint32_t R_len
= bits_pos
- R_pos
;
16444 char *P_pos
= strchr (bits_pos
, '*');
16446 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16448 uint32_t bits_len
= P_pos
- bits_pos
;
16452 char *enc_md_pos
= strchr (P_pos
, '*');
16454 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16456 uint32_t P_len
= enc_md_pos
- P_pos
;
16460 char *id_len_pos
= strchr (enc_md_pos
, '*');
16462 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16464 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16468 char *id_buf_pos
= strchr (id_len_pos
, '*');
16470 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16472 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16476 char *u_len_pos
= strchr (id_buf_pos
, '*');
16478 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16480 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16482 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16486 char *u_buf_pos
= strchr (u_len_pos
, '*');
16488 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16490 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16494 char *o_len_pos
= strchr (u_buf_pos
, '*');
16496 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16498 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16500 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16504 char *o_buf_pos
= strchr (o_len_pos
, '*');
16506 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16508 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16512 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;
16514 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16518 const int V
= atoi (V_pos
);
16519 const int R
= atoi (R_pos
);
16520 const int P
= atoi (P_pos
);
16524 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16525 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16527 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16529 const int id_len
= atoi (id_len_pos
);
16530 const int u_len
= atoi (u_len_pos
);
16531 const int o_len
= atoi (o_len_pos
);
16533 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16535 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16536 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16538 const int bits
= atoi (bits_pos
);
16540 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16546 enc_md
= atoi (enc_md_pos
);
16549 // copy data to esalt
16555 pdf
->enc_md
= enc_md
;
16557 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16558 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16559 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16560 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16564 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16565 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16566 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16567 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16570 pdf
->id_len
= id_len
;
16572 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16573 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16574 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16575 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16576 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16577 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16578 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16579 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16580 pdf
->u_len
= u_len
;
16582 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16583 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16584 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16585 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16586 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16587 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16588 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16589 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16590 pdf
->o_len
= o_len
;
16592 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16593 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16594 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16595 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16599 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16600 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16601 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16602 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16605 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16606 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16607 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16608 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16609 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16610 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16611 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16612 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16614 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16615 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16616 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16617 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16618 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16619 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16620 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16621 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16623 // precompute rc4 data for later use
16639 uint salt_pc_block
[32];
16641 char *salt_pc_ptr
= (char *) salt_pc_block
;
16643 memcpy (salt_pc_ptr
, padding
, 32);
16644 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16646 uint salt_pc_digest
[4];
16648 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16650 pdf
->rc4data
[0] = salt_pc_digest
[0];
16651 pdf
->rc4data
[1] = salt_pc_digest
[1];
16653 // we use ID for salt, maybe needs to change, we will see...
16655 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16656 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16657 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16658 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16659 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16660 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16661 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16662 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16663 salt
->salt_len
= pdf
->id_len
+ 16;
16665 salt
->salt_iter
= ROUNDS_PDF14
;
16667 digest
[0] = pdf
->u_buf
[0];
16668 digest
[1] = pdf
->u_buf
[1];
16672 return (PARSER_OK
);
16675 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16677 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16679 if (ret
!= PARSER_OK
)
16684 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16686 salt_t
*salt
= hash_buf
->salt
;
16688 digest
[0] -= SHA256M_A
;
16689 digest
[1] -= SHA256M_B
;
16690 digest
[2] -= SHA256M_C
;
16691 digest
[3] -= SHA256M_D
;
16692 digest
[4] -= SHA256M_E
;
16693 digest
[5] -= SHA256M_F
;
16694 digest
[6] -= SHA256M_G
;
16695 digest
[7] -= SHA256M_H
;
16697 salt
->salt_buf
[2] = 0x80;
16699 return (PARSER_OK
);
16702 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16704 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16706 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16708 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16710 salt_t
*salt
= hash_buf
->salt
;
16712 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16718 char *V_pos
= input_buf
+ 5;
16720 char *R_pos
= strchr (V_pos
, '*');
16722 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16724 uint32_t V_len
= R_pos
- V_pos
;
16728 char *bits_pos
= strchr (R_pos
, '*');
16730 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16732 uint32_t R_len
= bits_pos
- R_pos
;
16736 char *P_pos
= strchr (bits_pos
, '*');
16738 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16740 uint32_t bits_len
= P_pos
- bits_pos
;
16744 char *enc_md_pos
= strchr (P_pos
, '*');
16746 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16748 uint32_t P_len
= enc_md_pos
- P_pos
;
16752 char *id_len_pos
= strchr (enc_md_pos
, '*');
16754 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16756 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16760 char *id_buf_pos
= strchr (id_len_pos
, '*');
16762 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16764 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16768 char *u_len_pos
= strchr (id_buf_pos
, '*');
16770 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16772 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16776 char *u_buf_pos
= strchr (u_len_pos
, '*');
16778 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16780 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16784 char *o_len_pos
= strchr (u_buf_pos
, '*');
16786 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16788 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16792 char *o_buf_pos
= strchr (o_len_pos
, '*');
16794 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16796 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16800 char *last
= strchr (o_buf_pos
, '*');
16802 if (last
== NULL
) last
= input_buf
+ input_len
;
16804 uint32_t o_buf_len
= last
- o_buf_pos
;
16808 const int V
= atoi (V_pos
);
16809 const int R
= atoi (R_pos
);
16813 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16814 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16816 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16818 const int bits
= atoi (bits_pos
);
16820 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16822 int enc_md
= atoi (enc_md_pos
);
16824 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16826 const uint id_len
= atoi (id_len_pos
);
16827 const uint u_len
= atoi (u_len_pos
);
16828 const uint o_len
= atoi (o_len_pos
);
16830 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16831 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16832 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16833 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16834 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16835 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16836 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16837 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16839 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16840 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16841 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16843 // copy data to esalt
16845 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16847 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16849 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16852 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16853 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16855 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16856 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16858 salt
->salt_len
= 8;
16859 salt
->salt_iter
= ROUNDS_PDF17L8
;
16861 digest
[0] = pdf
->u_buf
[0];
16862 digest
[1] = pdf
->u_buf
[1];
16863 digest
[2] = pdf
->u_buf
[2];
16864 digest
[3] = pdf
->u_buf
[3];
16865 digest
[4] = pdf
->u_buf
[4];
16866 digest
[5] = pdf
->u_buf
[5];
16867 digest
[6] = pdf
->u_buf
[6];
16868 digest
[7] = pdf
->u_buf
[7];
16870 return (PARSER_OK
);
16873 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16875 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16877 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16879 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16881 salt_t
*salt
= hash_buf
->salt
;
16883 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16891 char *iter_pos
= input_buf
+ 7;
16893 uint32_t iter
= atoi (iter_pos
);
16895 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16896 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16898 // first is *raw* salt
16900 char *salt_pos
= strchr (iter_pos
, ':');
16902 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16906 char *hash_pos
= strchr (salt_pos
, ':');
16908 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16910 uint32_t salt_len
= hash_pos
- salt_pos
;
16912 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16916 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16918 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16922 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16924 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16926 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16928 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16929 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16931 salt
->salt_len
= salt_len
;
16932 salt
->salt_iter
= iter
- 1;
16938 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16940 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16942 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16944 memcpy (digest
, tmp_buf
, 16);
16946 digest
[0] = byte_swap_32 (digest
[0]);
16947 digest
[1] = byte_swap_32 (digest
[1]);
16948 digest
[2] = byte_swap_32 (digest
[2]);
16949 digest
[3] = byte_swap_32 (digest
[3]);
16951 // add some stuff to normal salt to make sorted happy
16953 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16954 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16955 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16956 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16957 salt
->salt_buf
[4] = salt
->salt_iter
;
16959 return (PARSER_OK
);
16962 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16964 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16966 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16968 salt_t
*salt
= hash_buf
->salt
;
16970 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16971 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16972 digest
[2] = hex_to_uint (&input_buf
[16]);
16973 digest
[3] = hex_to_uint (&input_buf
[24]);
16975 digest
[0] = byte_swap_32 (digest
[0]);
16976 digest
[1] = byte_swap_32 (digest
[1]);
16977 digest
[2] = byte_swap_32 (digest
[2]);
16978 digest
[3] = byte_swap_32 (digest
[3]);
16980 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16982 uint salt_len
= input_len
- 32 - 1;
16984 char *salt_buf
= input_buf
+ 32 + 1;
16986 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16988 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16990 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16992 salt
->salt_len
= salt_len
;
16994 return (PARSER_OK
);
16997 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16999 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17001 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17003 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17005 salt_t
*salt
= hash_buf
->salt
;
17007 char *user_pos
= input_buf
+ 10;
17009 char *salt_pos
= strchr (user_pos
, '*');
17011 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17015 char *hash_pos
= strchr (salt_pos
, '*');
17019 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17021 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17023 uint user_len
= salt_pos
- user_pos
- 1;
17025 uint salt_len
= hash_pos
- salt_pos
- 1;
17027 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17033 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17034 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17035 digest
[2] = hex_to_uint (&hash_pos
[16]);
17036 digest
[3] = hex_to_uint (&hash_pos
[24]);
17038 digest
[0] = byte_swap_32 (digest
[0]);
17039 digest
[1] = byte_swap_32 (digest
[1]);
17040 digest
[2] = byte_swap_32 (digest
[2]);
17041 digest
[3] = byte_swap_32 (digest
[3]);
17043 digest
[0] -= MD5M_A
;
17044 digest
[1] -= MD5M_B
;
17045 digest
[2] -= MD5M_C
;
17046 digest
[3] -= MD5M_D
;
17052 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17054 // first 4 bytes are the "challenge"
17056 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17057 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17058 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17059 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17061 // append the user name
17063 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17065 salt
->salt_len
= 4 + user_len
;
17067 return (PARSER_OK
);
17070 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17072 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17074 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17076 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17078 salt_t
*salt
= hash_buf
->salt
;
17080 char *salt_pos
= input_buf
+ 9;
17082 char *hash_pos
= strchr (salt_pos
, '*');
17084 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17088 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17090 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17092 uint salt_len
= hash_pos
- salt_pos
- 1;
17094 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17100 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17101 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17102 digest
[2] = hex_to_uint (&hash_pos
[16]);
17103 digest
[3] = hex_to_uint (&hash_pos
[24]);
17104 digest
[4] = hex_to_uint (&hash_pos
[32]);
17110 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17112 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17114 salt
->salt_len
= salt_len
;
17116 return (PARSER_OK
);
17119 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17121 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17123 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17125 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17127 salt_t
*salt
= hash_buf
->salt
;
17129 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17135 char *cry_master_len_pos
= input_buf
+ 9;
17137 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17139 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17143 cry_master_buf_pos
++;
17145 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17147 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17151 cry_salt_len_pos
++;
17153 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17155 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17157 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17159 cry_salt_buf_pos
++;
17161 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17163 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17169 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17171 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17173 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17177 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17179 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17181 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17185 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17187 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17189 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17191 public_key_len_pos
++;
17193 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17195 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17197 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17199 public_key_buf_pos
++;
17201 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;
17203 const uint cry_master_len
= atoi (cry_master_len_pos
);
17204 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17205 const uint ckey_len
= atoi (ckey_len_pos
);
17206 const uint public_key_len
= atoi (public_key_len_pos
);
17208 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17209 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17210 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17211 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17213 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17215 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17217 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17220 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17222 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17224 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17227 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17229 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17231 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17234 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17235 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17236 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17239 * store digest (should be unique enought, hopefully)
17242 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17243 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17244 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17245 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17251 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17253 const uint cry_rounds
= atoi (cry_rounds_pos
);
17255 salt
->salt_iter
= cry_rounds
- 1;
17257 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17259 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17261 salt
->salt_len
= salt_len
;
17263 return (PARSER_OK
);
17266 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17268 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17270 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17272 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17274 salt_t
*salt
= hash_buf
->salt
;
17276 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17278 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17280 char temp_input_buf
[input_len
+ 1];
17282 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17283 memcpy (temp_input_buf
, input_buf
, input_len
);
17287 char *URI_server_pos
= temp_input_buf
+ 6;
17289 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17291 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17293 URI_client_pos
[0] = 0;
17296 uint URI_server_len
= strlen (URI_server_pos
);
17298 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17302 char *user_pos
= strchr (URI_client_pos
, '*');
17304 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17309 uint URI_client_len
= strlen (URI_client_pos
);
17311 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17315 char *realm_pos
= strchr (user_pos
, '*');
17317 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17322 uint user_len
= strlen (user_pos
);
17324 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17328 char *method_pos
= strchr (realm_pos
, '*');
17330 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17335 uint realm_len
= strlen (realm_pos
);
17337 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17341 char *URI_prefix_pos
= strchr (method_pos
, '*');
17343 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17345 URI_prefix_pos
[0] = 0;
17348 uint method_len
= strlen (method_pos
);
17350 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17354 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17356 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17358 URI_resource_pos
[0] = 0;
17359 URI_resource_pos
++;
17361 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17363 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17367 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17369 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17371 URI_suffix_pos
[0] = 0;
17374 uint URI_resource_len
= strlen (URI_resource_pos
);
17376 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17377 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17381 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17383 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17388 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17390 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17394 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17396 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17398 nonce_client_pos
[0] = 0;
17399 nonce_client_pos
++;
17401 uint nonce_len
= strlen (nonce_pos
);
17403 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17404 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17408 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17410 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17412 nonce_count_pos
[0] = 0;
17415 uint nonce_client_len
= strlen (nonce_client_pos
);
17417 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17421 char *qop_pos
= strchr (nonce_count_pos
, '*');
17423 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17428 uint nonce_count_len
= strlen (nonce_count_pos
);
17430 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17434 char *directive_pos
= strchr (qop_pos
, '*');
17436 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17438 directive_pos
[0] = 0;
17441 uint qop_len
= strlen (qop_pos
);
17443 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17447 char *digest_pos
= strchr (directive_pos
, '*');
17449 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17454 uint directive_len
= strlen (directive_pos
);
17456 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17458 if (memcmp (directive_pos
, "MD5", 3))
17460 log_info ("ERROR: only the MD5 directive is currently supported\n");
17462 return (PARSER_SIP_AUTH_DIRECTIVE
);
17466 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17471 uint md5_max_len
= 4 * 64;
17473 uint md5_remaining_len
= md5_max_len
;
17475 uint tmp_md5_buf
[md5_max_len
/ 4];
17477 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17479 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17481 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17483 md5_len
+= method_len
+ 1;
17484 tmp_md5_ptr
+= method_len
+ 1;
17486 if (URI_prefix_len
> 0)
17488 md5_remaining_len
= md5_max_len
- md5_len
;
17490 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17492 md5_len
+= URI_prefix_len
+ 1;
17493 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17496 md5_remaining_len
= md5_max_len
- md5_len
;
17498 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17500 md5_len
+= URI_resource_len
;
17501 tmp_md5_ptr
+= URI_resource_len
;
17503 if (URI_suffix_len
> 0)
17505 md5_remaining_len
= md5_max_len
- md5_len
;
17507 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17509 md5_len
+= 1 + URI_suffix_len
;
17512 uint tmp_digest
[4];
17514 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17516 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17517 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17518 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17519 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17525 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17527 uint esalt_len
= 0;
17529 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17531 // there are 2 possibilities for the esalt:
17533 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17535 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17537 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17539 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17551 esalt_len
= 1 + nonce_len
+ 1 + 32;
17553 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17555 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17563 // add 0x80 to esalt
17565 esalt_buf_ptr
[esalt_len
] = 0x80;
17567 sip
->esalt_len
= esalt_len
;
17573 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17575 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17577 uint max_salt_len
= 119;
17579 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17581 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17583 sip
->salt_len
= salt_len
;
17586 * fake salt (for sorting)
17589 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17593 uint fake_salt_len
= salt_len
;
17595 if (fake_salt_len
> max_salt_len
)
17597 fake_salt_len
= max_salt_len
;
17600 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17602 salt
->salt_len
= fake_salt_len
;
17608 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17609 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17610 digest
[2] = hex_to_uint (&digest_pos
[16]);
17611 digest
[3] = hex_to_uint (&digest_pos
[24]);
17613 digest
[0] = byte_swap_32 (digest
[0]);
17614 digest
[1] = byte_swap_32 (digest
[1]);
17615 digest
[2] = byte_swap_32 (digest
[2]);
17616 digest
[3] = byte_swap_32 (digest
[3]);
17618 return (PARSER_OK
);
17621 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17623 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17625 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17627 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17629 salt_t
*salt
= hash_buf
->salt
;
17633 char *digest_pos
= input_buf
;
17635 digest
[0] = hex_to_uint (&digest_pos
[0]);
17642 char *salt_buf
= input_buf
+ 8 + 1;
17646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17652 salt
->salt_len
= salt_len
;
17654 return (PARSER_OK
);
17657 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17659 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17661 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17663 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17665 salt_t
*salt
= hash_buf
->salt
;
17667 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17673 char *p_buf_pos
= input_buf
+ 4;
17675 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17677 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17679 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17681 NumCyclesPower_pos
++;
17683 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17685 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17687 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17691 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17693 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17695 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17699 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17701 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17703 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17707 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17709 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17711 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17715 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17717 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17719 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17723 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17725 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17727 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17731 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17733 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17735 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17739 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17741 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17743 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17747 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;
17749 const uint iter
= atoi (NumCyclesPower_pos
);
17750 const uint crc
= atoi (crc_buf_pos
);
17751 const uint p_buf
= atoi (p_buf_pos
);
17752 const uint salt_len
= atoi (salt_len_pos
);
17753 const uint iv_len
= atoi (iv_len_pos
);
17754 const uint unpack_size
= atoi (unpack_size_pos
);
17755 const uint data_len
= atoi (data_len_pos
);
17761 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17762 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17764 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17766 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17768 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17774 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17775 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17776 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17777 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17779 seven_zip
->iv_len
= iv_len
;
17781 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17783 seven_zip
->salt_len
= 0;
17785 seven_zip
->crc
= crc
;
17787 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17789 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17791 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17794 seven_zip
->data_len
= data_len
;
17796 seven_zip
->unpack_size
= unpack_size
;
17800 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17801 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17802 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17803 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17805 salt
->salt_len
= 16;
17807 salt
->salt_sign
[0] = iter
;
17809 salt
->salt_iter
= 1 << iter
;
17820 return (PARSER_OK
);
17823 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17825 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17827 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17829 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17830 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17831 digest
[2] = hex_to_uint (&input_buf
[16]);
17832 digest
[3] = hex_to_uint (&input_buf
[24]);
17833 digest
[4] = hex_to_uint (&input_buf
[32]);
17834 digest
[5] = hex_to_uint (&input_buf
[40]);
17835 digest
[6] = hex_to_uint (&input_buf
[48]);
17836 digest
[7] = hex_to_uint (&input_buf
[56]);
17838 digest
[0] = byte_swap_32 (digest
[0]);
17839 digest
[1] = byte_swap_32 (digest
[1]);
17840 digest
[2] = byte_swap_32 (digest
[2]);
17841 digest
[3] = byte_swap_32 (digest
[3]);
17842 digest
[4] = byte_swap_32 (digest
[4]);
17843 digest
[5] = byte_swap_32 (digest
[5]);
17844 digest
[6] = byte_swap_32 (digest
[6]);
17845 digest
[7] = byte_swap_32 (digest
[7]);
17847 return (PARSER_OK
);
17850 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17852 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17854 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17856 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17857 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17858 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17859 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17860 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17861 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17862 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17863 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17864 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17865 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17866 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17867 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17868 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17869 digest
[13] = hex_to_uint (&input_buf
[104]);
17870 digest
[14] = hex_to_uint (&input_buf
[112]);
17871 digest
[15] = hex_to_uint (&input_buf
[120]);
17873 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17874 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17875 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17876 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17877 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17878 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17879 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17880 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17881 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17882 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17883 digest
[10] = byte_swap_32 (digest
[10]);
17884 digest
[11] = byte_swap_32 (digest
[11]);
17885 digest
[12] = byte_swap_32 (digest
[12]);
17886 digest
[13] = byte_swap_32 (digest
[13]);
17887 digest
[14] = byte_swap_32 (digest
[14]);
17888 digest
[15] = byte_swap_32 (digest
[15]);
17890 return (PARSER_OK
);
17893 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17895 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17897 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17899 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17901 salt_t
*salt
= hash_buf
->salt
;
17903 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17911 char *iter_pos
= input_buf
+ 4;
17913 uint32_t iter
= atoi (iter_pos
);
17915 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17916 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17918 // first is *raw* salt
17920 char *salt_pos
= strchr (iter_pos
, ':');
17922 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17926 char *hash_pos
= strchr (salt_pos
, ':');
17928 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17930 uint32_t salt_len
= hash_pos
- salt_pos
;
17932 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17936 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17938 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17942 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17944 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17946 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17948 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17949 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17951 salt
->salt_len
= salt_len
;
17952 salt
->salt_iter
= iter
- 1;
17958 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17960 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17962 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17964 memcpy (digest
, tmp_buf
, 16);
17966 // add some stuff to normal salt to make sorted happy
17968 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17969 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17970 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17971 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17972 salt
->salt_buf
[4] = salt
->salt_iter
;
17974 return (PARSER_OK
);
17977 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17979 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17981 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17983 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17985 salt_t
*salt
= hash_buf
->salt
;
17987 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
17995 char *iter_pos
= input_buf
+ 5;
17997 uint32_t iter
= atoi (iter_pos
);
17999 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18000 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18002 // first is *raw* salt
18004 char *salt_pos
= strchr (iter_pos
, ':');
18006 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18010 char *hash_pos
= strchr (salt_pos
, ':');
18012 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18014 uint32_t salt_len
= hash_pos
- salt_pos
;
18016 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18020 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18022 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18026 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18028 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18030 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18032 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18033 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18035 salt
->salt_len
= salt_len
;
18036 salt
->salt_iter
= iter
- 1;
18042 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18044 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18046 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18048 memcpy (digest
, tmp_buf
, 16);
18050 digest
[0] = byte_swap_32 (digest
[0]);
18051 digest
[1] = byte_swap_32 (digest
[1]);
18052 digest
[2] = byte_swap_32 (digest
[2]);
18053 digest
[3] = byte_swap_32 (digest
[3]);
18055 // add some stuff to normal salt to make sorted happy
18057 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18058 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18059 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18060 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18061 salt
->salt_buf
[4] = salt
->salt_iter
;
18063 return (PARSER_OK
);
18066 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18068 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18070 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18072 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18074 salt_t
*salt
= hash_buf
->salt
;
18076 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18084 char *iter_pos
= input_buf
+ 7;
18086 uint32_t iter
= atoi (iter_pos
);
18088 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18089 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18091 // first is *raw* salt
18093 char *salt_pos
= strchr (iter_pos
, ':');
18095 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18099 char *hash_pos
= strchr (salt_pos
, ':');
18101 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18103 uint32_t salt_len
= hash_pos
- salt_pos
;
18105 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18109 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18111 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18115 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18117 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18119 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18121 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18122 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18124 salt
->salt_len
= salt_len
;
18125 salt
->salt_iter
= iter
- 1;
18131 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18133 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18135 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18137 memcpy (digest
, tmp_buf
, 64);
18139 digest
[0] = byte_swap_64 (digest
[0]);
18140 digest
[1] = byte_swap_64 (digest
[1]);
18141 digest
[2] = byte_swap_64 (digest
[2]);
18142 digest
[3] = byte_swap_64 (digest
[3]);
18143 digest
[4] = byte_swap_64 (digest
[4]);
18144 digest
[5] = byte_swap_64 (digest
[5]);
18145 digest
[6] = byte_swap_64 (digest
[6]);
18146 digest
[7] = byte_swap_64 (digest
[7]);
18148 // add some stuff to normal salt to make sorted happy
18150 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18151 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18152 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18153 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18154 salt
->salt_buf
[4] = salt
->salt_iter
;
18156 return (PARSER_OK
);
18159 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18161 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18163 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18165 uint
*digest
= (uint
*) hash_buf
->digest
;
18167 salt_t
*salt
= hash_buf
->salt
;
18173 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18175 char *hash_pos
= strchr (salt_pos
, '$');
18177 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18179 uint32_t salt_len
= hash_pos
- salt_pos
;
18181 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18185 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18187 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18191 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18192 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18210 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18211 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18213 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18214 salt
->salt_len
= 8;
18216 return (PARSER_OK
);
18219 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18221 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18223 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18225 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18227 if (c19
& 3) return (PARSER_HASH_VALUE
);
18229 salt_t
*salt
= hash_buf
->salt
;
18231 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18235 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18236 | itoa64_to_int (input_buf
[2]) << 6
18237 | itoa64_to_int (input_buf
[3]) << 12
18238 | itoa64_to_int (input_buf
[4]) << 18;
18242 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18243 | itoa64_to_int (input_buf
[6]) << 6
18244 | itoa64_to_int (input_buf
[7]) << 12
18245 | itoa64_to_int (input_buf
[8]) << 18;
18247 salt
->salt_len
= 4;
18251 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18253 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18255 memcpy (digest
, tmp_buf
, 8);
18259 IP (digest
[0], digest
[1], tt
);
18261 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18262 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18266 return (PARSER_OK
);
18269 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18271 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18273 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18275 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18277 salt_t
*salt
= hash_buf
->salt
;
18283 char *type_pos
= input_buf
+ 6 + 1;
18285 char *salt_pos
= strchr (type_pos
, '*');
18287 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18289 uint32_t type_len
= salt_pos
- type_pos
;
18291 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18295 char *crypted_pos
= strchr (salt_pos
, '*');
18297 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18299 uint32_t salt_len
= crypted_pos
- salt_pos
;
18301 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18305 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18307 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18313 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18314 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18316 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18317 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18319 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18320 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18321 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18322 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18324 salt
->salt_len
= 24;
18325 salt
->salt_iter
= ROUNDS_RAR3
;
18327 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18328 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18330 digest
[0] = 0xc43d7b00;
18331 digest
[1] = 0x40070000;
18335 return (PARSER_OK
);
18338 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18340 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18342 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18344 salt_t
*salt
= hash_buf
->salt
;
18346 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18347 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18348 digest
[2] = hex_to_uint (&input_buf
[16]);
18349 digest
[3] = hex_to_uint (&input_buf
[24]);
18350 digest
[4] = hex_to_uint (&input_buf
[32]);
18351 digest
[5] = hex_to_uint (&input_buf
[40]);
18352 digest
[6] = hex_to_uint (&input_buf
[48]);
18353 digest
[7] = hex_to_uint (&input_buf
[56]);
18355 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18357 uint salt_len
= input_len
- 64 - 1;
18359 char *salt_buf
= input_buf
+ 64 + 1;
18361 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18363 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18365 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18367 salt
->salt_len
= salt_len
;
18370 * we can precompute the first sha256 transform
18375 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18376 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18377 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18378 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18379 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18380 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18381 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18382 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18383 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18384 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18385 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18386 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18387 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18388 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18389 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18390 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18394 pc256
[0] = SHA256M_A
;
18395 pc256
[1] = SHA256M_B
;
18396 pc256
[2] = SHA256M_C
;
18397 pc256
[3] = SHA256M_D
;
18398 pc256
[4] = SHA256M_E
;
18399 pc256
[5] = SHA256M_F
;
18400 pc256
[6] = SHA256M_G
;
18401 pc256
[7] = SHA256M_H
;
18403 sha256_64 (w
, pc256
);
18405 salt
->salt_buf_pc
[0] = pc256
[0];
18406 salt
->salt_buf_pc
[1] = pc256
[1];
18407 salt
->salt_buf_pc
[2] = pc256
[2];
18408 salt
->salt_buf_pc
[3] = pc256
[3];
18409 salt
->salt_buf_pc
[4] = pc256
[4];
18410 salt
->salt_buf_pc
[5] = pc256
[5];
18411 salt
->salt_buf_pc
[6] = pc256
[6];
18412 salt
->salt_buf_pc
[7] = pc256
[7];
18414 digest
[0] -= pc256
[0];
18415 digest
[1] -= pc256
[1];
18416 digest
[2] -= pc256
[2];
18417 digest
[3] -= pc256
[3];
18418 digest
[4] -= pc256
[4];
18419 digest
[5] -= pc256
[5];
18420 digest
[6] -= pc256
[6];
18421 digest
[7] -= pc256
[7];
18423 return (PARSER_OK
);
18426 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18428 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18430 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18432 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18434 salt_t
*salt
= hash_buf
->salt
;
18440 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18442 char *data_buf_pos
= strchr (data_len_pos
, '$');
18444 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18446 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18448 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18449 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18453 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18455 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18457 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18459 uint32_t data_len
= atoi (data_len_pos
);
18461 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18467 char *salt_pos
= data_buf_pos
;
18469 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18470 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18471 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18472 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18474 // this is actually the CT, which is also the hash later (if matched)
18476 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18477 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18478 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18479 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18481 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18483 salt
->salt_iter
= 10 - 1;
18489 digest
[0] = salt
->salt_buf
[4];
18490 digest
[1] = salt
->salt_buf
[5];
18491 digest
[2] = salt
->salt_buf
[6];
18492 digest
[3] = salt
->salt_buf
[7];
18494 return (PARSER_OK
);
18497 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18499 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18501 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18503 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18505 salt_t
*salt
= hash_buf
->salt
;
18511 char *salt_pos
= input_buf
+ 11 + 1;
18513 char *iter_pos
= strchr (salt_pos
, ',');
18515 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18517 uint32_t salt_len
= iter_pos
- salt_pos
;
18519 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18523 char *hash_pos
= strchr (iter_pos
, ',');
18525 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18527 uint32_t iter_len
= hash_pos
- iter_pos
;
18529 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18533 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18535 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18541 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18542 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18543 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18544 salt
->salt_buf
[3] = 0x00018000;
18546 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18547 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18548 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18549 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18551 salt
->salt_len
= salt_len
/ 2;
18553 salt
->salt_iter
= atoi (iter_pos
) - 1;
18559 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18560 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18561 digest
[2] = hex_to_uint (&hash_pos
[16]);
18562 digest
[3] = hex_to_uint (&hash_pos
[24]);
18563 digest
[4] = hex_to_uint (&hash_pos
[32]);
18564 digest
[5] = hex_to_uint (&hash_pos
[40]);
18565 digest
[6] = hex_to_uint (&hash_pos
[48]);
18566 digest
[7] = hex_to_uint (&hash_pos
[56]);
18568 return (PARSER_OK
);
18572 * parallel running threads
18577 BOOL WINAPI
sigHandler_default (DWORD sig
)
18581 case CTRL_CLOSE_EVENT
:
18584 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18585 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18586 * function otherwise it is to late (e.g. after returning from this function)
18591 SetConsoleCtrlHandler (NULL
, TRUE
);
18598 case CTRL_LOGOFF_EVENT
:
18599 case CTRL_SHUTDOWN_EVENT
:
18603 SetConsoleCtrlHandler (NULL
, TRUE
);
18611 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18615 case CTRL_CLOSE_EVENT
:
18619 SetConsoleCtrlHandler (NULL
, TRUE
);
18626 case CTRL_LOGOFF_EVENT
:
18627 case CTRL_SHUTDOWN_EVENT
:
18631 SetConsoleCtrlHandler (NULL
, TRUE
);
18639 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18641 if (callback
== NULL
)
18643 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18647 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18653 void sigHandler_default (int sig
)
18657 signal (sig
, NULL
);
18660 void sigHandler_benchmark (int sig
)
18664 signal (sig
, NULL
);
18667 void hc_signal (void (callback
) (int))
18669 if (callback
== NULL
) callback
= SIG_DFL
;
18671 signal (SIGINT
, callback
);
18672 signal (SIGTERM
, callback
);
18673 signal (SIGABRT
, callback
);
18678 void status_display ();
18680 void *thread_keypress (void *p
)
18682 int benchmark
= *((int *) p
);
18684 uint quiet
= data
.quiet
;
18688 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18690 int ch
= tty_getchar();
18692 if (ch
== -1) break;
18694 if (ch
== 0) continue;
18700 hc_thread_mutex_lock (mux_display
);
18715 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18716 if (quiet
== 0) fflush (stdout
);
18728 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18729 if (quiet
== 0) fflush (stdout
);
18741 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18742 if (quiet
== 0) fflush (stdout
);
18754 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18755 if (quiet
== 0) fflush (stdout
);
18763 if (benchmark
== 1) break;
18765 stop_at_checkpoint ();
18769 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18770 if (quiet
== 0) fflush (stdout
);
18778 if (benchmark
== 1)
18790 hc_thread_mutex_unlock (mux_display
);
18802 bool class_num (char c
)
18804 return ((c
>= '0') && (c
<= '9'));
18807 bool class_lower (char c
)
18809 return ((c
>= 'a') && (c
<= 'z'));
18812 bool class_upper (char c
)
18814 return ((c
>= 'A') && (c
<= 'Z'));
18817 bool class_alpha (char c
)
18819 return (class_lower (c
) || class_upper (c
));
18822 char conv_ctoi (char c
)
18828 else if (class_upper (c
))
18830 return c
- 'A' + (char) 10;
18833 return (char) (-1);
18836 char conv_itoc (char c
)
18844 return c
+ 'A' - (char) 10;
18847 return (char) (-1);
18854 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18855 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18856 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18857 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18858 #define MAX_GPU_RULES 14
18859 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18860 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18861 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18863 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18864 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18865 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18866 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18868 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18873 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18875 switch (rule_buf
[rule_pos
])
18881 case RULE_OP_MANGLE_NOOP
:
18882 SET_NAME (rule
, rule_buf
[rule_pos
]);
18885 case RULE_OP_MANGLE_LREST
:
18886 SET_NAME (rule
, rule_buf
[rule_pos
]);
18889 case RULE_OP_MANGLE_UREST
:
18890 SET_NAME (rule
, rule_buf
[rule_pos
]);
18893 case RULE_OP_MANGLE_LREST_UFIRST
:
18894 SET_NAME (rule
, rule_buf
[rule_pos
]);
18897 case RULE_OP_MANGLE_UREST_LFIRST
:
18898 SET_NAME (rule
, rule_buf
[rule_pos
]);
18901 case RULE_OP_MANGLE_TREST
:
18902 SET_NAME (rule
, rule_buf
[rule_pos
]);
18905 case RULE_OP_MANGLE_TOGGLE_AT
:
18906 SET_NAME (rule
, rule_buf
[rule_pos
]);
18907 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18910 case RULE_OP_MANGLE_REVERSE
:
18911 SET_NAME (rule
, rule_buf
[rule_pos
]);
18914 case RULE_OP_MANGLE_DUPEWORD
:
18915 SET_NAME (rule
, rule_buf
[rule_pos
]);
18918 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18919 SET_NAME (rule
, rule_buf
[rule_pos
]);
18920 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18923 case RULE_OP_MANGLE_REFLECT
:
18924 SET_NAME (rule
, rule_buf
[rule_pos
]);
18927 case RULE_OP_MANGLE_ROTATE_LEFT
:
18928 SET_NAME (rule
, rule_buf
[rule_pos
]);
18931 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18932 SET_NAME (rule
, rule_buf
[rule_pos
]);
18935 case RULE_OP_MANGLE_APPEND
:
18936 SET_NAME (rule
, rule_buf
[rule_pos
]);
18937 SET_P0 (rule
, rule_buf
[rule_pos
]);
18940 case RULE_OP_MANGLE_PREPEND
:
18941 SET_NAME (rule
, rule_buf
[rule_pos
]);
18942 SET_P0 (rule
, rule_buf
[rule_pos
]);
18945 case RULE_OP_MANGLE_DELETE_FIRST
:
18946 SET_NAME (rule
, rule_buf
[rule_pos
]);
18949 case RULE_OP_MANGLE_DELETE_LAST
:
18950 SET_NAME (rule
, rule_buf
[rule_pos
]);
18953 case RULE_OP_MANGLE_DELETE_AT
:
18954 SET_NAME (rule
, rule_buf
[rule_pos
]);
18955 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18958 case RULE_OP_MANGLE_EXTRACT
:
18959 SET_NAME (rule
, rule_buf
[rule_pos
]);
18960 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18961 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18964 case RULE_OP_MANGLE_OMIT
:
18965 SET_NAME (rule
, rule_buf
[rule_pos
]);
18966 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18967 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18970 case RULE_OP_MANGLE_INSERT
:
18971 SET_NAME (rule
, rule_buf
[rule_pos
]);
18972 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18973 SET_P1 (rule
, rule_buf
[rule_pos
]);
18976 case RULE_OP_MANGLE_OVERSTRIKE
:
18977 SET_NAME (rule
, rule_buf
[rule_pos
]);
18978 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18979 SET_P1 (rule
, rule_buf
[rule_pos
]);
18982 case RULE_OP_MANGLE_TRUNCATE_AT
:
18983 SET_NAME (rule
, rule_buf
[rule_pos
]);
18984 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18987 case RULE_OP_MANGLE_REPLACE
:
18988 SET_NAME (rule
, rule_buf
[rule_pos
]);
18989 SET_P0 (rule
, rule_buf
[rule_pos
]);
18990 SET_P1 (rule
, rule_buf
[rule_pos
]);
18993 case RULE_OP_MANGLE_PURGECHAR
:
18997 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19001 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19002 SET_NAME (rule
, rule_buf
[rule_pos
]);
19003 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19006 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19007 SET_NAME (rule
, rule_buf
[rule_pos
]);
19008 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19011 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19012 SET_NAME (rule
, rule_buf
[rule_pos
]);
19015 case RULE_OP_MANGLE_SWITCH_FIRST
:
19016 SET_NAME (rule
, rule_buf
[rule_pos
]);
19019 case RULE_OP_MANGLE_SWITCH_LAST
:
19020 SET_NAME (rule
, rule_buf
[rule_pos
]);
19023 case RULE_OP_MANGLE_SWITCH_AT
:
19024 SET_NAME (rule
, rule_buf
[rule_pos
]);
19025 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19026 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19029 case RULE_OP_MANGLE_CHR_SHIFTL
:
19030 SET_NAME (rule
, rule_buf
[rule_pos
]);
19031 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19034 case RULE_OP_MANGLE_CHR_SHIFTR
:
19035 SET_NAME (rule
, rule_buf
[rule_pos
]);
19036 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19039 case RULE_OP_MANGLE_CHR_INCR
:
19040 SET_NAME (rule
, rule_buf
[rule_pos
]);
19041 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19044 case RULE_OP_MANGLE_CHR_DECR
:
19045 SET_NAME (rule
, rule_buf
[rule_pos
]);
19046 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19049 case RULE_OP_MANGLE_REPLACE_NP1
:
19050 SET_NAME (rule
, rule_buf
[rule_pos
]);
19051 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19054 case RULE_OP_MANGLE_REPLACE_NM1
:
19055 SET_NAME (rule
, rule_buf
[rule_pos
]);
19056 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19059 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19060 SET_NAME (rule
, rule_buf
[rule_pos
]);
19061 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19064 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19065 SET_NAME (rule
, rule_buf
[rule_pos
]);
19066 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19069 case RULE_OP_MANGLE_TITLE
:
19070 SET_NAME (rule
, rule_buf
[rule_pos
]);
19079 if (rule_pos
< rule_len
) return (-1);
19084 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19088 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19092 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19096 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19100 case RULE_OP_MANGLE_NOOP
:
19101 rule_buf
[rule_pos
] = rule_cmd
;
19104 case RULE_OP_MANGLE_LREST
:
19105 rule_buf
[rule_pos
] = rule_cmd
;
19108 case RULE_OP_MANGLE_UREST
:
19109 rule_buf
[rule_pos
] = rule_cmd
;
19112 case RULE_OP_MANGLE_LREST_UFIRST
:
19113 rule_buf
[rule_pos
] = rule_cmd
;
19116 case RULE_OP_MANGLE_UREST_LFIRST
:
19117 rule_buf
[rule_pos
] = rule_cmd
;
19120 case RULE_OP_MANGLE_TREST
:
19121 rule_buf
[rule_pos
] = rule_cmd
;
19124 case RULE_OP_MANGLE_TOGGLE_AT
:
19125 rule_buf
[rule_pos
] = rule_cmd
;
19126 GET_P0_CONV (rule
);
19129 case RULE_OP_MANGLE_REVERSE
:
19130 rule_buf
[rule_pos
] = rule_cmd
;
19133 case RULE_OP_MANGLE_DUPEWORD
:
19134 rule_buf
[rule_pos
] = rule_cmd
;
19137 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19138 rule_buf
[rule_pos
] = rule_cmd
;
19139 GET_P0_CONV (rule
);
19142 case RULE_OP_MANGLE_REFLECT
:
19143 rule_buf
[rule_pos
] = rule_cmd
;
19146 case RULE_OP_MANGLE_ROTATE_LEFT
:
19147 rule_buf
[rule_pos
] = rule_cmd
;
19150 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19151 rule_buf
[rule_pos
] = rule_cmd
;
19154 case RULE_OP_MANGLE_APPEND
:
19155 rule_buf
[rule_pos
] = rule_cmd
;
19159 case RULE_OP_MANGLE_PREPEND
:
19160 rule_buf
[rule_pos
] = rule_cmd
;
19164 case RULE_OP_MANGLE_DELETE_FIRST
:
19165 rule_buf
[rule_pos
] = rule_cmd
;
19168 case RULE_OP_MANGLE_DELETE_LAST
:
19169 rule_buf
[rule_pos
] = rule_cmd
;
19172 case RULE_OP_MANGLE_DELETE_AT
:
19173 rule_buf
[rule_pos
] = rule_cmd
;
19174 GET_P0_CONV (rule
);
19177 case RULE_OP_MANGLE_EXTRACT
:
19178 rule_buf
[rule_pos
] = rule_cmd
;
19179 GET_P0_CONV (rule
);
19180 GET_P1_CONV (rule
);
19183 case RULE_OP_MANGLE_OMIT
:
19184 rule_buf
[rule_pos
] = rule_cmd
;
19185 GET_P0_CONV (rule
);
19186 GET_P1_CONV (rule
);
19189 case RULE_OP_MANGLE_INSERT
:
19190 rule_buf
[rule_pos
] = rule_cmd
;
19191 GET_P0_CONV (rule
);
19195 case RULE_OP_MANGLE_OVERSTRIKE
:
19196 rule_buf
[rule_pos
] = rule_cmd
;
19197 GET_P0_CONV (rule
);
19201 case RULE_OP_MANGLE_TRUNCATE_AT
:
19202 rule_buf
[rule_pos
] = rule_cmd
;
19203 GET_P0_CONV (rule
);
19206 case RULE_OP_MANGLE_REPLACE
:
19207 rule_buf
[rule_pos
] = rule_cmd
;
19212 case RULE_OP_MANGLE_PURGECHAR
:
19216 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19220 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19221 rule_buf
[rule_pos
] = rule_cmd
;
19222 GET_P0_CONV (rule
);
19225 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19226 rule_buf
[rule_pos
] = rule_cmd
;
19227 GET_P0_CONV (rule
);
19230 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19231 rule_buf
[rule_pos
] = rule_cmd
;
19234 case RULE_OP_MANGLE_SWITCH_FIRST
:
19235 rule_buf
[rule_pos
] = rule_cmd
;
19238 case RULE_OP_MANGLE_SWITCH_LAST
:
19239 rule_buf
[rule_pos
] = rule_cmd
;
19242 case RULE_OP_MANGLE_SWITCH_AT
:
19243 rule_buf
[rule_pos
] = rule_cmd
;
19244 GET_P0_CONV (rule
);
19245 GET_P1_CONV (rule
);
19248 case RULE_OP_MANGLE_CHR_SHIFTL
:
19249 rule_buf
[rule_pos
] = rule_cmd
;
19250 GET_P0_CONV (rule
);
19253 case RULE_OP_MANGLE_CHR_SHIFTR
:
19254 rule_buf
[rule_pos
] = rule_cmd
;
19255 GET_P0_CONV (rule
);
19258 case RULE_OP_MANGLE_CHR_INCR
:
19259 rule_buf
[rule_pos
] = rule_cmd
;
19260 GET_P0_CONV (rule
);
19263 case RULE_OP_MANGLE_CHR_DECR
:
19264 rule_buf
[rule_pos
] = rule_cmd
;
19265 GET_P0_CONV (rule
);
19268 case RULE_OP_MANGLE_REPLACE_NP1
:
19269 rule_buf
[rule_pos
] = rule_cmd
;
19270 GET_P0_CONV (rule
);
19273 case RULE_OP_MANGLE_REPLACE_NM1
:
19274 rule_buf
[rule_pos
] = rule_cmd
;
19275 GET_P0_CONV (rule
);
19278 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19279 rule_buf
[rule_pos
] = rule_cmd
;
19280 GET_P0_CONV (rule
);
19283 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19284 rule_buf
[rule_pos
] = rule_cmd
;
19285 GET_P0_CONV (rule
);
19288 case RULE_OP_MANGLE_TITLE
:
19289 rule_buf
[rule_pos
] = rule_cmd
;
19293 return rule_pos
- 1;
19311 * CPU rules : this is from hashcat sources, cpu based rules
19314 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19315 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19317 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19318 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19319 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19321 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19322 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19323 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19325 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19329 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19334 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19338 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19343 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19347 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19352 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19357 for (l
= 0; l
< arr_len
; l
++)
19359 r
= arr_len
- 1 - l
;
19363 MANGLE_SWITCH (arr
, l
, r
);
19369 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19371 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19373 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19375 return (arr_len
* 2);
19378 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19380 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19382 int orig_len
= arr_len
;
19386 for (i
= 0; i
< times
; i
++)
19388 memcpy (&arr
[arr_len
], arr
, orig_len
);
19390 arr_len
+= orig_len
;
19396 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19398 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19400 mangle_double (arr
, arr_len
);
19402 mangle_reverse (arr
+ arr_len
, arr_len
);
19404 return (arr_len
* 2);
19407 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19412 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19414 MANGLE_SWITCH (arr
, l
, r
);
19420 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19425 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19427 MANGLE_SWITCH (arr
, l
, r
);
19433 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19435 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19439 return (arr_len
+ 1);
19442 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19444 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19448 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19450 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19455 return (arr_len
+ 1);
19458 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19460 if (upos
>= arr_len
) return (arr_len
);
19464 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19466 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19469 return (arr_len
- 1);
19472 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19474 if (upos
>= arr_len
) return (arr_len
);
19476 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19480 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19482 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19488 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19490 if (upos
>= arr_len
) return (arr_len
);
19492 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19496 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19498 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19501 return (arr_len
- ulen
);
19504 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19506 if (upos
>= arr_len
) return (arr_len
);
19508 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19512 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19514 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19519 return (arr_len
+ 1);
19522 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
)
19524 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19526 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19528 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19530 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19532 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19534 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19536 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19538 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19540 return (arr_len
+ arr2_cpy
);
19543 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19545 if (upos
>= arr_len
) return (arr_len
);
19552 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19554 if (upos
>= arr_len
) return (arr_len
);
19556 memset (arr
+ upos
, 0, arr_len
- upos
);
19561 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19565 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19567 if (arr
[arr_pos
] != oldc
) continue;
19569 arr
[arr_pos
] = newc
;
19575 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19581 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19583 if (arr
[arr_pos
] == c
) continue;
19585 arr
[ret_len
] = arr
[arr_pos
];
19593 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19595 if (ulen
> arr_len
) return (arr_len
);
19597 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19601 memcpy (cs
, arr
, ulen
);
19605 for (i
= 0; i
< ulen
; i
++)
19609 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19615 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19617 if (ulen
> arr_len
) return (arr_len
);
19619 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19621 int upos
= arr_len
- ulen
;
19625 for (i
= 0; i
< ulen
; i
++)
19627 char c
= arr
[upos
+ i
];
19629 arr_len
= mangle_append (arr
, arr_len
, c
);
19635 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19637 if ( arr_len
== 0) return (arr_len
);
19638 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19640 char c
= arr
[upos
];
19644 for (i
= 0; i
< ulen
; i
++)
19646 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19652 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19654 if ( arr_len
== 0) return (arr_len
);
19655 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19659 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19661 int new_pos
= arr_pos
* 2;
19663 arr
[new_pos
] = arr
[arr_pos
];
19665 arr
[new_pos
+ 1] = arr
[arr_pos
];
19668 return (arr_len
* 2);
19671 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19673 if (upos
>= arr_len
) return (arr_len
);
19674 if (upos2
>= arr_len
) return (arr_len
);
19676 MANGLE_SWITCH (arr
, upos
, upos2
);
19681 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19683 MANGLE_SWITCH (arr
, upos
, upos2
);
19688 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19690 if (upos
>= arr_len
) return (arr_len
);
19697 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19699 if (upos
>= arr_len
) return (arr_len
);
19706 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19708 if (upos
>= arr_len
) return (arr_len
);
19715 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19717 if (upos
>= arr_len
) return (arr_len
);
19724 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19726 int upper_next
= 1;
19730 for (pos
= 0; pos
< arr_len
; pos
++)
19732 if (arr
[pos
] == ' ')
19743 MANGLE_UPPER_AT (arr
, pos
);
19747 MANGLE_LOWER_AT (arr
, pos
);
19754 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19756 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19760 uint32_t rule_pos
= 0;
19762 for (j
= 0; j
< rp_gen_num
; j
++)
19769 switch ((char) get_random_num (0, 9))
19772 r
= get_random_num (0, sizeof (grp_op_nop
));
19773 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19777 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19778 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19779 p1
= get_random_num (0, sizeof (grp_pos
));
19780 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19784 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19785 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19786 p1
= get_random_num (1, 6);
19787 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19791 r
= get_random_num (0, sizeof (grp_op_chr
));
19792 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19793 p1
= get_random_num (0x20, 0x7e);
19794 rule_buf
[rule_pos
++] = (char) p1
;
19798 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19799 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19800 p1
= get_random_num (0x20, 0x7e);
19801 rule_buf
[rule_pos
++] = (char) p1
;
19802 p2
= get_random_num (0x20, 0x7e);
19804 p2
= get_random_num (0x20, 0x7e);
19805 rule_buf
[rule_pos
++] = (char) p2
;
19809 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19810 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19811 p1
= get_random_num (0, sizeof (grp_pos
));
19812 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19813 p2
= get_random_num (0x20, 0x7e);
19814 rule_buf
[rule_pos
++] = (char) p2
;
19818 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19819 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19820 p1
= get_random_num (0, sizeof (grp_pos
));
19821 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19822 p2
= get_random_num (0, sizeof (grp_pos
));
19824 p2
= get_random_num (0, sizeof (grp_pos
));
19825 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19829 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19830 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19831 p1
= get_random_num (0, sizeof (grp_pos
));
19832 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19833 p2
= get_random_num (1, sizeof (grp_pos
));
19835 p2
= get_random_num (1, sizeof (grp_pos
));
19836 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19840 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19841 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19842 p1
= get_random_num (0, sizeof (grp_pos
));
19843 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19844 p2
= get_random_num (1, sizeof (grp_pos
));
19845 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19846 p3
= get_random_num (0, sizeof (grp_pos
));
19847 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19855 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19857 char mem
[BLOCK_SIZE
];
19859 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19861 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19863 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19865 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19867 int out_len
= in_len
;
19868 int mem_len
= in_len
;
19870 memcpy (out
, in
, out_len
);
19874 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19876 int upos
; int upos2
;
19879 switch (rule
[rule_pos
])
19884 case RULE_OP_MANGLE_NOOP
:
19887 case RULE_OP_MANGLE_LREST
:
19888 out_len
= mangle_lrest (out
, out_len
);
19891 case RULE_OP_MANGLE_UREST
:
19892 out_len
= mangle_urest (out
, out_len
);
19895 case RULE_OP_MANGLE_LREST_UFIRST
:
19896 out_len
= mangle_lrest (out
, out_len
);
19897 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19900 case RULE_OP_MANGLE_UREST_LFIRST
:
19901 out_len
= mangle_urest (out
, out_len
);
19902 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19905 case RULE_OP_MANGLE_TREST
:
19906 out_len
= mangle_trest (out
, out_len
);
19909 case RULE_OP_MANGLE_TOGGLE_AT
:
19910 NEXT_RULEPOS (rule_pos
);
19911 NEXT_RPTOI (rule
, rule_pos
, upos
);
19912 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19915 case RULE_OP_MANGLE_REVERSE
:
19916 out_len
= mangle_reverse (out
, out_len
);
19919 case RULE_OP_MANGLE_DUPEWORD
:
19920 out_len
= mangle_double (out
, out_len
);
19923 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19924 NEXT_RULEPOS (rule_pos
);
19925 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19926 out_len
= mangle_double_times (out
, out_len
, ulen
);
19929 case RULE_OP_MANGLE_REFLECT
:
19930 out_len
= mangle_reflect (out
, out_len
);
19933 case RULE_OP_MANGLE_ROTATE_LEFT
:
19934 mangle_rotate_left (out
, out_len
);
19937 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19938 mangle_rotate_right (out
, out_len
);
19941 case RULE_OP_MANGLE_APPEND
:
19942 NEXT_RULEPOS (rule_pos
);
19943 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19946 case RULE_OP_MANGLE_PREPEND
:
19947 NEXT_RULEPOS (rule_pos
);
19948 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19951 case RULE_OP_MANGLE_DELETE_FIRST
:
19952 out_len
= mangle_delete_at (out
, out_len
, 0);
19955 case RULE_OP_MANGLE_DELETE_LAST
:
19956 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19959 case RULE_OP_MANGLE_DELETE_AT
:
19960 NEXT_RULEPOS (rule_pos
);
19961 NEXT_RPTOI (rule
, rule_pos
, upos
);
19962 out_len
= mangle_delete_at (out
, out_len
, upos
);
19965 case RULE_OP_MANGLE_EXTRACT
:
19966 NEXT_RULEPOS (rule_pos
);
19967 NEXT_RPTOI (rule
, rule_pos
, upos
);
19968 NEXT_RULEPOS (rule_pos
);
19969 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19970 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19973 case RULE_OP_MANGLE_OMIT
:
19974 NEXT_RULEPOS (rule_pos
);
19975 NEXT_RPTOI (rule
, rule_pos
, upos
);
19976 NEXT_RULEPOS (rule_pos
);
19977 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19978 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19981 case RULE_OP_MANGLE_INSERT
:
19982 NEXT_RULEPOS (rule_pos
);
19983 NEXT_RPTOI (rule
, rule_pos
, upos
);
19984 NEXT_RULEPOS (rule_pos
);
19985 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19988 case RULE_OP_MANGLE_OVERSTRIKE
:
19989 NEXT_RULEPOS (rule_pos
);
19990 NEXT_RPTOI (rule
, rule_pos
, upos
);
19991 NEXT_RULEPOS (rule_pos
);
19992 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
19995 case RULE_OP_MANGLE_TRUNCATE_AT
:
19996 NEXT_RULEPOS (rule_pos
);
19997 NEXT_RPTOI (rule
, rule_pos
, upos
);
19998 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20001 case RULE_OP_MANGLE_REPLACE
:
20002 NEXT_RULEPOS (rule_pos
);
20003 NEXT_RULEPOS (rule_pos
);
20004 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20007 case RULE_OP_MANGLE_PURGECHAR
:
20008 NEXT_RULEPOS (rule_pos
);
20009 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20012 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20016 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20017 NEXT_RULEPOS (rule_pos
);
20018 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20019 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20022 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20023 NEXT_RULEPOS (rule_pos
);
20024 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20025 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20028 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20029 out_len
= mangle_dupechar (out
, out_len
);
20032 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20033 NEXT_RULEPOS (rule_pos
);
20034 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20035 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20038 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20039 NEXT_RULEPOS (rule_pos
);
20040 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20041 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20044 case RULE_OP_MANGLE_SWITCH_FIRST
:
20045 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20048 case RULE_OP_MANGLE_SWITCH_LAST
:
20049 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20052 case RULE_OP_MANGLE_SWITCH_AT
:
20053 NEXT_RULEPOS (rule_pos
);
20054 NEXT_RPTOI (rule
, rule_pos
, upos
);
20055 NEXT_RULEPOS (rule_pos
);
20056 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20057 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20060 case RULE_OP_MANGLE_CHR_SHIFTL
:
20061 NEXT_RULEPOS (rule_pos
);
20062 NEXT_RPTOI (rule
, rule_pos
, upos
);
20063 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20066 case RULE_OP_MANGLE_CHR_SHIFTR
:
20067 NEXT_RULEPOS (rule_pos
);
20068 NEXT_RPTOI (rule
, rule_pos
, upos
);
20069 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20072 case RULE_OP_MANGLE_CHR_INCR
:
20073 NEXT_RULEPOS (rule_pos
);
20074 NEXT_RPTOI (rule
, rule_pos
, upos
);
20075 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20078 case RULE_OP_MANGLE_CHR_DECR
:
20079 NEXT_RULEPOS (rule_pos
);
20080 NEXT_RPTOI (rule
, rule_pos
, upos
);
20081 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20084 case RULE_OP_MANGLE_REPLACE_NP1
:
20085 NEXT_RULEPOS (rule_pos
);
20086 NEXT_RPTOI (rule
, rule_pos
, upos
);
20087 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20090 case RULE_OP_MANGLE_REPLACE_NM1
:
20091 NEXT_RULEPOS (rule_pos
);
20092 NEXT_RPTOI (rule
, rule_pos
, upos
);
20093 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20096 case RULE_OP_MANGLE_TITLE
:
20097 out_len
= mangle_title (out
, out_len
);
20100 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20101 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20102 NEXT_RULEPOS (rule_pos
);
20103 NEXT_RPTOI (rule
, rule_pos
, upos
);
20104 NEXT_RULEPOS (rule_pos
);
20105 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20106 NEXT_RULEPOS (rule_pos
);
20107 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20108 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20111 case RULE_OP_MANGLE_APPEND_MEMORY
:
20112 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20113 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20114 memcpy (out
+ out_len
, mem
, mem_len
);
20115 out_len
+= mem_len
;
20118 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20119 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20120 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20121 memcpy (mem
+ mem_len
, out
, out_len
);
20122 out_len
+= mem_len
;
20123 memcpy (out
, mem
, out_len
);
20126 case RULE_OP_MEMORIZE_WORD
:
20127 memcpy (mem
, out
, out_len
);
20131 case RULE_OP_REJECT_LESS
:
20132 NEXT_RULEPOS (rule_pos
);
20133 NEXT_RPTOI (rule
, rule_pos
, upos
);
20134 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20137 case RULE_OP_REJECT_GREATER
:
20138 NEXT_RULEPOS (rule_pos
);
20139 NEXT_RPTOI (rule
, rule_pos
, upos
);
20140 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20143 case RULE_OP_REJECT_CONTAIN
:
20144 NEXT_RULEPOS (rule_pos
);
20145 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20148 case RULE_OP_REJECT_NOT_CONTAIN
:
20149 NEXT_RULEPOS (rule_pos
);
20150 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20153 case RULE_OP_REJECT_EQUAL_FIRST
:
20154 NEXT_RULEPOS (rule_pos
);
20155 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20158 case RULE_OP_REJECT_EQUAL_LAST
:
20159 NEXT_RULEPOS (rule_pos
);
20160 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20163 case RULE_OP_REJECT_EQUAL_AT
:
20164 NEXT_RULEPOS (rule_pos
);
20165 NEXT_RPTOI (rule
, rule_pos
, upos
);
20166 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20167 NEXT_RULEPOS (rule_pos
);
20168 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20171 case RULE_OP_REJECT_CONTAINS
:
20172 NEXT_RULEPOS (rule_pos
);
20173 NEXT_RPTOI (rule
, rule_pos
, upos
);
20174 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20175 NEXT_RULEPOS (rule_pos
);
20176 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20177 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20180 case RULE_OP_REJECT_MEMORY
:
20181 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20185 return (RULE_RC_SYNTAX_ERROR
);
20190 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);