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 *install_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", install_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_install_dir (const char *progname
)
4077 char *install_dir
= mystrdup (progname
);
4078 char *last_slash
= NULL
;
4080 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4084 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4090 install_dir
[0] = '.';
4094 return (install_dir
);
4097 char *get_profile_dir (const char *homedir
)
4099 #define DOT_HASHCAT ".hashcat"
4101 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4103 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4108 char *get_session_dir (const char *profile_dir
, const char *session
)
4110 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (session
) + 1);
4112 sprintf (session_dir
, "%s/%s", profile_dir
, session
);
4117 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4121 FILE *fd
= fopen (file
, "rb");
4125 log_error ("%s: %s", file
, strerror (errno
));
4130 #define MAX_KEY_SIZE (1024 * 1024)
4132 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4134 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4138 for (int fpos
= 0; fpos
< nread
; fpos
++)
4140 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4142 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4143 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4144 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4145 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4147 if (kpos
>= 64) kpos
= 0;
4155 void set_cpu_affinity (char *cpu_affinity
)
4158 DWORD_PTR aff_mask
= 0;
4169 char *devices
= strdup (cpu_affinity
);
4171 char *next
= strtok (devices
, ",");
4175 uint cpu_id
= atoi (next
);
4192 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4198 aff_mask
|= 1 << (cpu_id
- 1);
4202 CPU_SET ((cpu_id
- 1), &cpuset
);
4205 } while ((next
= strtok (NULL
, ",")) != NULL
);
4211 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4212 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4216 pthread_t thread
= pthread_self ();
4217 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4221 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4223 char *element
, *end
;
4225 end
= (char *) base
+ nmemb
* size
;
4227 for (element
= (char *) base
; element
< end
; element
+= size
)
4228 if (!compar (element
, key
))
4234 int sort_by_salt (const void *v1
, const void *v2
)
4236 const salt_t
*s1
= (const salt_t
*) v1
;
4237 const salt_t
*s2
= (const salt_t
*) v2
;
4239 const int res1
= s1
->salt_len
- s2
->salt_len
;
4241 if (res1
!= 0) return (res1
);
4243 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4245 if (res2
!= 0) return (res2
);
4253 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4254 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4261 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4262 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4268 int sort_by_salt_buf (const void *v1
, const void *v2
)
4270 const pot_t
*p1
= (const pot_t
*) v1
;
4271 const pot_t
*p2
= (const pot_t
*) v2
;
4273 const hash_t
*h1
= &p1
->hash
;
4274 const hash_t
*h2
= &p2
->hash
;
4276 const salt_t
*s1
= h1
->salt
;
4277 const salt_t
*s2
= h2
->salt
;
4283 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4284 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4290 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4292 const hash_t
*h1
= (const hash_t
*) v1
;
4293 const hash_t
*h2
= (const hash_t
*) v2
;
4295 const salt_t
*s1
= h1
->salt
;
4296 const salt_t
*s2
= h2
->salt
;
4298 // testphase: this should work
4303 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4304 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4307 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4308 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4309 if (s1->salt_len > s2->salt_len) return ( 1);
4310 if (s1->salt_len < s2->salt_len) return (-1);
4312 uint n = s1->salt_len;
4316 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4317 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4324 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4326 const hash_t
*h1
= (const hash_t
*) v1
;
4327 const hash_t
*h2
= (const hash_t
*) v2
;
4329 const salt_t
*s1
= h1
->salt
;
4330 const salt_t
*s2
= h2
->salt
;
4332 // 12 - 2 (since last 2 uints contain the digest)
4337 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4338 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4344 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4346 const hash_t
*h1
= (const hash_t
*) v1
;
4347 const hash_t
*h2
= (const hash_t
*) v2
;
4349 const void *d1
= h1
->digest
;
4350 const void *d2
= h2
->digest
;
4352 return data
.sort_by_digest (d1
, d2
);
4355 int sort_by_hash (const void *v1
, const void *v2
)
4357 const hash_t
*h1
= (const hash_t
*) v1
;
4358 const hash_t
*h2
= (const hash_t
*) v2
;
4362 const salt_t
*s1
= h1
->salt
;
4363 const salt_t
*s2
= h2
->salt
;
4365 int res
= sort_by_salt (s1
, s2
);
4367 if (res
!= 0) return (res
);
4370 const void *d1
= h1
->digest
;
4371 const void *d2
= h2
->digest
;
4373 return data
.sort_by_digest (d1
, d2
);
4376 int sort_by_pot (const void *v1
, const void *v2
)
4378 const pot_t
*p1
= (const pot_t
*) v1
;
4379 const pot_t
*p2
= (const pot_t
*) v2
;
4381 const hash_t
*h1
= &p1
->hash
;
4382 const hash_t
*h2
= &p2
->hash
;
4384 return sort_by_hash (h1
, h2
);
4387 int sort_by_mtime (const void *p1
, const void *p2
)
4389 const char **f1
= (const char **) p1
;
4390 const char **f2
= (const char **) p2
;
4392 struct stat s1
; stat (*f1
, &s1
);
4393 struct stat s2
; stat (*f2
, &s2
);
4395 return s2
.st_mtime
- s1
.st_mtime
;
4398 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4400 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4401 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4403 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4406 int sort_by_gpu_rule (const void *p1
, const void *p2
)
4408 const gpu_rule_t
*r1
= (const gpu_rule_t
*) p1
;
4409 const gpu_rule_t
*r2
= (const gpu_rule_t
*) p2
;
4411 return memcmp (r1
, r2
, sizeof (gpu_rule_t
));
4414 int sort_by_stringptr (const void *p1
, const void *p2
)
4416 const char **s1
= (const char **) p1
;
4417 const char **s2
= (const char **) p2
;
4419 return strcmp (*s1
, *s2
);
4422 int sort_by_dictstat (const void *s1
, const void *s2
)
4424 dictstat_t
*d1
= (dictstat_t
*) s1
;
4425 dictstat_t
*d2
= (dictstat_t
*) s2
;
4428 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4430 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4433 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4436 int sort_by_bitmap (const void *p1
, const void *p2
)
4438 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4439 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4441 return b1
->collisions
- b2
->collisions
;
4444 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4446 const uint32_t *d1
= (const uint32_t *) v1
;
4447 const uint32_t *d2
= (const uint32_t *) v2
;
4453 if (d1
[n
] > d2
[n
]) return ( 1);
4454 if (d1
[n
] < d2
[n
]) return (-1);
4460 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4462 const uint32_t *d1
= (const uint32_t *) v1
;
4463 const uint32_t *d2
= (const uint32_t *) v2
;
4469 if (d1
[n
] > d2
[n
]) return ( 1);
4470 if (d1
[n
] < d2
[n
]) return (-1);
4476 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4478 const uint32_t *d1
= (const uint32_t *) v1
;
4479 const uint32_t *d2
= (const uint32_t *) v2
;
4485 if (d1
[n
] > d2
[n
]) return ( 1);
4486 if (d1
[n
] < d2
[n
]) return (-1);
4492 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4494 const uint32_t *d1
= (const uint32_t *) v1
;
4495 const uint32_t *d2
= (const uint32_t *) v2
;
4501 if (d1
[n
] > d2
[n
]) return ( 1);
4502 if (d1
[n
] < d2
[n
]) return (-1);
4508 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4510 const uint32_t *d1
= (const uint32_t *) v1
;
4511 const uint32_t *d2
= (const uint32_t *) v2
;
4517 if (d1
[n
] > d2
[n
]) return ( 1);
4518 if (d1
[n
] < d2
[n
]) return (-1);
4524 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4526 const uint32_t *d1
= (const uint32_t *) v1
;
4527 const uint32_t *d2
= (const uint32_t *) v2
;
4533 if (d1
[n
] > d2
[n
]) return ( 1);
4534 if (d1
[n
] < d2
[n
]) return (-1);
4540 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4542 const uint32_t *d1
= (const uint32_t *) v1
;
4543 const uint32_t *d2
= (const uint32_t *) v2
;
4549 if (d1
[n
] > d2
[n
]) return ( 1);
4550 if (d1
[n
] < d2
[n
]) return (-1);
4556 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4558 const uint32_t *d1
= (const uint32_t *) v1
;
4559 const uint32_t *d2
= (const uint32_t *) v2
;
4565 if (d1
[n
] > d2
[n
]) return ( 1);
4566 if (d1
[n
] < d2
[n
]) return (-1);
4572 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4574 const uint64_t *d1
= (const uint64_t *) v1
;
4575 const uint64_t *d2
= (const uint64_t *) v2
;
4581 if (d1
[n
] > d2
[n
]) return ( 1);
4582 if (d1
[n
] < d2
[n
]) return (-1);
4588 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4590 const uint64_t *d1
= (const uint64_t *) v1
;
4591 const uint64_t *d2
= (const uint64_t *) v2
;
4597 if (d1
[n
] > d2
[n
]) return ( 1);
4598 if (d1
[n
] < d2
[n
]) return (-1);
4604 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4606 const uint64_t *d1
= (const uint64_t *) v1
;
4607 const uint64_t *d2
= (const uint64_t *) v2
;
4613 if (d1
[n
] > d2
[n
]) return ( 1);
4614 if (d1
[n
] < d2
[n
]) return (-1);
4620 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4622 const uint32_t *d1
= (const uint32_t *) v1
;
4623 const uint32_t *d2
= (const uint32_t *) v2
;
4625 const uint dgst_pos0
= data
.dgst_pos0
;
4626 const uint dgst_pos1
= data
.dgst_pos1
;
4627 const uint dgst_pos2
= data
.dgst_pos2
;
4628 const uint dgst_pos3
= data
.dgst_pos3
;
4630 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4631 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4632 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4633 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4634 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4635 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4636 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4637 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4642 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
)
4644 uint outfile_autohex
= data
.outfile_autohex
;
4646 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4648 FILE *debug_fp
= NULL
;
4650 if (debug_file
!= NULL
)
4652 debug_fp
= fopen (debug_file
, "ab");
4659 if (debug_fp
== NULL
)
4661 log_info ("WARNING: Could not open debug-file for writing");
4665 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4667 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4669 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4672 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4674 if (debug_mode
== 4)
4676 fputc (':', debug_fp
);
4678 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4681 fputc ('\n', debug_fp
);
4683 if (debug_file
!= NULL
) fclose (debug_fp
);
4687 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4689 int needs_hexify
= 0;
4691 if (outfile_autohex
== 1)
4693 for (uint i
= 0; i
< plain_len
; i
++)
4695 if (plain_ptr
[i
] < 0x20)
4702 if (plain_ptr
[i
] > 0x7f)
4711 if (needs_hexify
== 1)
4713 fprintf (fp
, "$HEX[");
4715 for (uint i
= 0; i
< plain_len
; i
++)
4717 fprintf (fp
, "%02x", plain_ptr
[i
]);
4724 fwrite (plain_ptr
, plain_len
, 1, fp
);
4728 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
)
4730 uint outfile_format
= data
.outfile_format
;
4732 char separator
= data
.separator
;
4734 if (outfile_format
& OUTFILE_FMT_HASH
)
4736 fprintf (out_fp
, "%s", out_buf
);
4738 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4740 fputc (separator
, out_fp
);
4743 else if (data
.username
)
4745 if (username
!= NULL
)
4747 for (uint i
= 0; i
< user_len
; i
++)
4749 fprintf (out_fp
, "%c", username
[i
]);
4752 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4754 fputc (separator
, out_fp
);
4759 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4761 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4763 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4765 fputc (separator
, out_fp
);
4769 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4771 for (uint i
= 0; i
< plain_len
; i
++)
4773 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4776 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4778 fputc (separator
, out_fp
);
4782 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4785 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4790 fprintf (out_fp
, "%lu", crackpos
);
4792 fprintf (out_fp
, "%llu", crackpos
);
4797 fputc ('\n', out_fp
);
4800 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
)
4804 pot_key
.hash
.salt
= hashes_buf
->salt
;
4805 pot_key
.hash
.digest
= hashes_buf
->digest
;
4807 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4813 input_buf
[input_len
] = 0;
4816 unsigned char *username
= NULL
;
4821 user_t
*user
= hashes_buf
->hash_info
->user
;
4825 username
= (unsigned char *) (user
->user_name
);
4827 user_len
= user
->user_len
;
4831 // do output the line
4832 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4836 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4837 #define LM_MASKED_PLAIN "[notfound]"
4839 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
)
4845 pot_left_key
.hash
.salt
= hash_left
->salt
;
4846 pot_left_key
.hash
.digest
= hash_left
->digest
;
4848 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4852 uint weak_hash_found
= 0;
4854 pot_t pot_right_key
;
4856 pot_right_key
.hash
.salt
= hash_right
->salt
;
4857 pot_right_key
.hash
.digest
= hash_right
->digest
;
4859 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4861 if (pot_right_ptr
== NULL
)
4863 // special case, if "weak hash"
4865 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4867 weak_hash_found
= 1;
4869 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4871 // in theory this is not needed, but we are paranoia:
4873 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4874 pot_right_ptr
->plain_len
= 0;
4878 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4880 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
4885 // at least one half was found:
4889 input_buf
[input_len
] = 0;
4893 unsigned char *username
= NULL
;
4898 user_t
*user
= hash_left
->hash_info
->user
;
4902 username
= (unsigned char *) (user
->user_name
);
4904 user_len
= user
->user_len
;
4908 // mask the part which was not found
4910 uint left_part_masked
= 0;
4911 uint right_part_masked
= 0;
4913 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4915 if (pot_left_ptr
== NULL
)
4917 left_part_masked
= 1;
4919 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4921 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4923 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4924 pot_left_ptr
->plain_len
= mask_plain_len
;
4927 if (pot_right_ptr
== NULL
)
4929 right_part_masked
= 1;
4931 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4933 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4935 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4936 pot_right_ptr
->plain_len
= mask_plain_len
;
4939 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4943 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4945 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4947 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4949 // do output the line
4951 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4953 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4955 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4956 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4959 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
)
4963 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4965 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4967 if (pot_ptr
== NULL
)
4971 input_buf
[input_len
] = 0;
4973 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
4977 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
)
4983 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
4985 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4989 pot_t pot_right_key
;
4991 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
4993 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4995 uint weak_hash_found
= 0;
4997 if (pot_right_ptr
== NULL
)
4999 // special case, if "weak hash"
5001 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5003 weak_hash_found
= 1;
5005 // we just need that pot_right_ptr is not a NULL pointer
5007 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5011 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5013 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5018 // ... at least one part was not cracked
5022 input_buf
[input_len
] = 0;
5024 // only show the hash part which is still not cracked
5026 uint user_len
= input_len
- 32;
5028 char hash_output
[user_len
+ 33];
5030 memset (hash_output
, 0, sizeof (hash_output
));
5032 memcpy (hash_output
, input_buf
, input_len
);
5034 if (pot_left_ptr
!= NULL
)
5036 // only show right part (because left part was already found)
5038 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5040 hash_output
[user_len
+ 16] = 0;
5043 if (pot_right_ptr
!= NULL
)
5045 // only show left part (because right part was already found)
5047 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5049 hash_output
[user_len
+ 16] = 0;
5052 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5054 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5057 uint
devices_to_devicemask (char *gpu_devices
)
5059 uint gpu_devicemask
= 0;
5063 char *devices
= strdup (gpu_devices
);
5065 char *next
= strtok (devices
, ",");
5069 uint gpu_id
= atoi (next
);
5071 if (gpu_id
< 1 || gpu_id
> 8)
5073 log_error ("ERROR: invalid gpu_id %u specified", gpu_id
);
5078 gpu_devicemask
|= 1 << (gpu_id
- 1);
5080 } while ((next
= strtok (NULL
, ",")) != NULL
);
5085 return gpu_devicemask
;
5088 uint
get_random_num (uint min
, uint max
)
5090 if (min
== max
) return (min
);
5092 return (uint
) ((rand () % (max
- min
)) + min
);
5095 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5097 uint32_t quotient
= dividend
/ divisor
;
5099 if (dividend
% divisor
) quotient
++;
5104 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5106 uint64_t quotient
= dividend
/ divisor
;
5108 if (dividend
% divisor
) quotient
++;
5113 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5115 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5116 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5118 if (tm
->tm_year
- 70)
5120 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5121 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5123 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5125 else if (tm
->tm_yday
)
5127 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5128 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5130 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5132 else if (tm
->tm_hour
)
5134 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5135 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5137 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5139 else if (tm
->tm_min
)
5141 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5142 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5144 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5148 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5150 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5154 void format_speed_display (float val
, char *buf
, size_t len
)
5165 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5176 /* generate output */
5180 snprintf (buf
, len
- 1, "%.0f ", val
);
5184 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5188 void lowercase (char *buf
, int len
)
5190 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5193 void uppercase (char *buf
, int len
)
5195 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5198 int fgetl (FILE *fp
, char *line_buf
)
5204 const int c
= fgetc (fp
);
5206 if (c
== EOF
) break;
5208 line_buf
[line_len
] = (char) c
;
5212 if (line_len
== BUFSIZ
) line_len
--;
5214 if (c
== '\n') break;
5217 if (line_len
== 0) return 0;
5219 if (line_buf
[line_len
- 1] == '\n')
5223 line_buf
[line_len
] = 0;
5226 if (line_len
== 0) return 0;
5228 if (line_buf
[line_len
- 1] == '\r')
5232 line_buf
[line_len
] = 0;
5238 int in_superchop (char *buf
)
5240 int len
= strlen (buf
);
5244 if (buf
[len
- 1] == '\n')
5251 if (buf
[len
- 1] == '\r')
5266 char **scan_directory (const char *path
)
5268 char *tmp_path
= mystrdup (path
);
5270 size_t tmp_path_len
= strlen (tmp_path
);
5272 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5274 tmp_path
[tmp_path_len
- 1] = 0;
5276 tmp_path_len
= strlen (tmp_path
);
5279 char **files
= NULL
;
5285 if ((d
= opendir (tmp_path
)) != NULL
)
5289 while ((de
= readdir (d
)) != NULL
)
5291 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5293 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5295 char *path_file
= (char *) mymalloc (path_size
+ 1);
5297 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5299 path_file
[path_size
] = 0;
5303 if ((d_test
= opendir (path_file
)) != NULL
)
5311 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5315 files
[num_files
- 1] = path_file
;
5321 else if (errno
== ENOTDIR
)
5323 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5327 files
[num_files
- 1] = mystrdup (path
);
5330 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5334 files
[num_files
- 1] = NULL
;
5341 int count_dictionaries (char **dictionary_files
)
5343 if (dictionary_files
== NULL
) return 0;
5347 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5355 char *stroptitype (const uint opti_type
)
5359 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5360 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5361 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5362 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5363 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5364 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5365 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5366 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5367 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5368 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5369 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5370 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5371 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5372 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5378 char *strparser (const uint parser_status
)
5380 switch (parser_status
)
5382 case PARSER_OK
: return ((char *) PA_000
); break;
5383 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5384 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5385 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5386 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5387 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5388 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5389 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5390 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5391 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5392 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5393 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5394 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5395 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5396 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5397 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5398 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5401 return ((char *) PA_255
);
5404 char *strhashtype (const uint hash_mode
)
5408 case 0: return ((char *) HT_00000
); break;
5409 case 10: return ((char *) HT_00010
); break;
5410 case 11: return ((char *) HT_00011
); break;
5411 case 12: return ((char *) HT_00012
); break;
5412 case 20: return ((char *) HT_00020
); break;
5413 case 21: return ((char *) HT_00021
); break;
5414 case 22: return ((char *) HT_00022
); break;
5415 case 23: return ((char *) HT_00023
); break;
5416 case 30: return ((char *) HT_00030
); break;
5417 case 40: return ((char *) HT_00040
); break;
5418 case 50: return ((char *) HT_00050
); break;
5419 case 60: return ((char *) HT_00060
); break;
5420 case 100: return ((char *) HT_00100
); break;
5421 case 101: return ((char *) HT_00101
); break;
5422 case 110: return ((char *) HT_00110
); break;
5423 case 111: return ((char *) HT_00111
); break;
5424 case 112: return ((char *) HT_00112
); break;
5425 case 120: return ((char *) HT_00120
); break;
5426 case 121: return ((char *) HT_00121
); break;
5427 case 122: return ((char *) HT_00122
); break;
5428 case 124: return ((char *) HT_00124
); break;
5429 case 130: return ((char *) HT_00130
); break;
5430 case 131: return ((char *) HT_00131
); break;
5431 case 132: return ((char *) HT_00132
); break;
5432 case 133: return ((char *) HT_00133
); break;
5433 case 140: return ((char *) HT_00140
); break;
5434 case 141: return ((char *) HT_00141
); break;
5435 case 150: return ((char *) HT_00150
); break;
5436 case 160: return ((char *) HT_00160
); break;
5437 case 190: return ((char *) HT_00190
); break;
5438 case 200: return ((char *) HT_00200
); break;
5439 case 300: return ((char *) HT_00300
); break;
5440 case 400: return ((char *) HT_00400
); break;
5441 case 500: return ((char *) HT_00500
); break;
5442 case 501: return ((char *) HT_00501
); break;
5443 case 900: return ((char *) HT_00900
); break;
5444 case 910: return ((char *) HT_00910
); break;
5445 case 1000: return ((char *) HT_01000
); break;
5446 case 1100: return ((char *) HT_01100
); break;
5447 case 1400: return ((char *) HT_01400
); break;
5448 case 1410: return ((char *) HT_01410
); break;
5449 case 1420: return ((char *) HT_01420
); break;
5450 case 1421: return ((char *) HT_01421
); break;
5451 case 1430: return ((char *) HT_01430
); break;
5452 case 1440: return ((char *) HT_01440
); break;
5453 case 1441: return ((char *) HT_01441
); break;
5454 case 1450: return ((char *) HT_01450
); break;
5455 case 1460: return ((char *) HT_01460
); break;
5456 case 1500: return ((char *) HT_01500
); break;
5457 case 1600: return ((char *) HT_01600
); break;
5458 case 1700: return ((char *) HT_01700
); break;
5459 case 1710: return ((char *) HT_01710
); break;
5460 case 1711: return ((char *) HT_01711
); break;
5461 case 1720: return ((char *) HT_01720
); break;
5462 case 1722: return ((char *) HT_01722
); break;
5463 case 1730: return ((char *) HT_01730
); break;
5464 case 1731: return ((char *) HT_01731
); break;
5465 case 1740: return ((char *) HT_01740
); break;
5466 case 1750: return ((char *) HT_01750
); break;
5467 case 1760: return ((char *) HT_01760
); break;
5468 case 1800: return ((char *) HT_01800
); break;
5469 case 2100: return ((char *) HT_02100
); break;
5470 case 2400: return ((char *) HT_02400
); break;
5471 case 2410: return ((char *) HT_02410
); break;
5472 case 2500: return ((char *) HT_02500
); break;
5473 case 2600: return ((char *) HT_02600
); break;
5474 case 2611: return ((char *) HT_02611
); break;
5475 case 2612: return ((char *) HT_02612
); break;
5476 case 2711: return ((char *) HT_02711
); break;
5477 case 2811: return ((char *) HT_02811
); break;
5478 case 3000: return ((char *) HT_03000
); break;
5479 case 3100: return ((char *) HT_03100
); break;
5480 case 3200: return ((char *) HT_03200
); break;
5481 case 3710: return ((char *) HT_03710
); break;
5482 case 3711: return ((char *) HT_03711
); break;
5483 case 3800: return ((char *) HT_03800
); break;
5484 case 4300: return ((char *) HT_04300
); break;
5485 case 4400: return ((char *) HT_04400
); break;
5486 case 4500: return ((char *) HT_04500
); break;
5487 case 4700: return ((char *) HT_04700
); break;
5488 case 4800: return ((char *) HT_04800
); break;
5489 case 4900: return ((char *) HT_04900
); break;
5490 case 5000: return ((char *) HT_05000
); break;
5491 case 5100: return ((char *) HT_05100
); break;
5492 case 5200: return ((char *) HT_05200
); break;
5493 case 5300: return ((char *) HT_05300
); break;
5494 case 5400: return ((char *) HT_05400
); break;
5495 case 5500: return ((char *) HT_05500
); break;
5496 case 5600: return ((char *) HT_05600
); break;
5497 case 5700: return ((char *) HT_05700
); break;
5498 case 5800: return ((char *) HT_05800
); break;
5499 case 6000: return ((char *) HT_06000
); break;
5500 case 6100: return ((char *) HT_06100
); break;
5501 case 6211: return ((char *) HT_06211
); break;
5502 case 6212: return ((char *) HT_06212
); break;
5503 case 6213: return ((char *) HT_06213
); break;
5504 case 6221: return ((char *) HT_06221
); break;
5505 case 6222: return ((char *) HT_06222
); break;
5506 case 6223: return ((char *) HT_06223
); break;
5507 case 6231: return ((char *) HT_06231
); break;
5508 case 6232: return ((char *) HT_06232
); break;
5509 case 6233: return ((char *) HT_06233
); break;
5510 case 6241: return ((char *) HT_06241
); break;
5511 case 6242: return ((char *) HT_06242
); break;
5512 case 6243: return ((char *) HT_06243
); break;
5513 case 6300: return ((char *) HT_06300
); break;
5514 case 6400: return ((char *) HT_06400
); break;
5515 case 6500: return ((char *) HT_06500
); break;
5516 case 6600: return ((char *) HT_06600
); break;
5517 case 6700: return ((char *) HT_06700
); break;
5518 case 6800: return ((char *) HT_06800
); break;
5519 case 6900: return ((char *) HT_06900
); break;
5520 case 7100: return ((char *) HT_07100
); break;
5521 case 7200: return ((char *) HT_07200
); break;
5522 case 7300: return ((char *) HT_07300
); break;
5523 case 7400: return ((char *) HT_07400
); break;
5524 case 7500: return ((char *) HT_07500
); break;
5525 case 7600: return ((char *) HT_07600
); break;
5526 case 7700: return ((char *) HT_07700
); break;
5527 case 7800: return ((char *) HT_07800
); break;
5528 case 7900: return ((char *) HT_07900
); break;
5529 case 8000: return ((char *) HT_08000
); break;
5530 case 8100: return ((char *) HT_08100
); break;
5531 case 8200: return ((char *) HT_08200
); break;
5532 case 8300: return ((char *) HT_08300
); break;
5533 case 8400: return ((char *) HT_08400
); break;
5534 case 8500: return ((char *) HT_08500
); break;
5535 case 8600: return ((char *) HT_08600
); break;
5536 case 8700: return ((char *) HT_08700
); break;
5537 case 8800: return ((char *) HT_08800
); break;
5538 case 8900: return ((char *) HT_08900
); break;
5539 case 9000: return ((char *) HT_09000
); break;
5540 case 9100: return ((char *) HT_09100
); break;
5541 case 9200: return ((char *) HT_09200
); break;
5542 case 9300: return ((char *) HT_09300
); break;
5543 case 9400: return ((char *) HT_09400
); break;
5544 case 9500: return ((char *) HT_09500
); break;
5545 case 9600: return ((char *) HT_09600
); break;
5546 case 9700: return ((char *) HT_09700
); break;
5547 case 9710: return ((char *) HT_09710
); break;
5548 case 9720: return ((char *) HT_09720
); break;
5549 case 9800: return ((char *) HT_09800
); break;
5550 case 9810: return ((char *) HT_09810
); break;
5551 case 9820: return ((char *) HT_09820
); break;
5552 case 9900: return ((char *) HT_09900
); break;
5553 case 10000: return ((char *) HT_10000
); break;
5554 case 10100: return ((char *) HT_10100
); break;
5555 case 10200: return ((char *) HT_10200
); break;
5556 case 10300: return ((char *) HT_10300
); break;
5557 case 10400: return ((char *) HT_10400
); break;
5558 case 10410: return ((char *) HT_10410
); break;
5559 case 10420: return ((char *) HT_10420
); break;
5560 case 10500: return ((char *) HT_10500
); break;
5561 case 10600: return ((char *) HT_10600
); break;
5562 case 10700: return ((char *) HT_10700
); break;
5563 case 10800: return ((char *) HT_10800
); break;
5564 case 10900: return ((char *) HT_10900
); break;
5565 case 11000: return ((char *) HT_11000
); break;
5566 case 11100: return ((char *) HT_11100
); break;
5567 case 11200: return ((char *) HT_11200
); break;
5568 case 11300: return ((char *) HT_11300
); break;
5569 case 11400: return ((char *) HT_11400
); break;
5570 case 11500: return ((char *) HT_11500
); break;
5571 case 11600: return ((char *) HT_11600
); break;
5572 case 11700: return ((char *) HT_11700
); break;
5573 case 11800: return ((char *) HT_11800
); break;
5574 case 11900: return ((char *) HT_11900
); break;
5575 case 12000: return ((char *) HT_12000
); break;
5576 case 12100: return ((char *) HT_12100
); break;
5577 case 12200: return ((char *) HT_12200
); break;
5578 case 12300: return ((char *) HT_12300
); break;
5579 case 12400: return ((char *) HT_12400
); break;
5580 case 12500: return ((char *) HT_12500
); break;
5581 case 12600: return ((char *) HT_12600
); break;
5582 case 12700: return ((char *) HT_12700
); break;
5583 case 12800: return ((char *) HT_12800
); break;
5586 return ((char *) "Unknown");
5589 char *strstatus (const uint devices_status
)
5591 switch (devices_status
)
5593 case STATUS_INIT
: return ((char *) ST_0000
); break;
5594 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5595 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5596 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5597 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5598 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5599 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5600 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5601 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5602 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5605 return ((char *) "Unknown");
5608 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5610 uint hash_type
= data
.hash_type
;
5611 uint hash_mode
= data
.hash_mode
;
5612 uint salt_type
= data
.salt_type
;
5613 uint opts_type
= data
.opts_type
;
5614 uint opti_type
= data
.opti_type
;
5615 uint dgst_size
= data
.dgst_size
;
5617 char *hashfile
= data
.hashfile
;
5621 uint digest_buf
[64];
5623 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5625 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5627 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5629 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5635 case HASH_TYPE_DESCRYPT
:
5636 FP (digest_buf
[1], digest_buf
[0], tt
);
5639 case HASH_TYPE_DESRACF
:
5640 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5641 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5643 FP (digest_buf
[1], digest_buf
[0], tt
);
5647 FP (digest_buf
[1], digest_buf
[0], tt
);
5650 case HASH_TYPE_NETNTLM
:
5651 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5652 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5653 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5654 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5656 FP (digest_buf
[1], digest_buf
[0], tt
);
5657 FP (digest_buf
[3], digest_buf
[2], tt
);
5660 case HASH_TYPE_BSDICRYPT
:
5661 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5662 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5664 FP (digest_buf
[1], digest_buf
[0], tt
);
5669 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5674 digest_buf
[0] += MD4M_A
;
5675 digest_buf
[1] += MD4M_B
;
5676 digest_buf
[2] += MD4M_C
;
5677 digest_buf
[3] += MD4M_D
;
5681 digest_buf
[0] += MD5M_A
;
5682 digest_buf
[1] += MD5M_B
;
5683 digest_buf
[2] += MD5M_C
;
5684 digest_buf
[3] += MD5M_D
;
5687 case HASH_TYPE_SHA1
:
5688 digest_buf
[0] += SHA1M_A
;
5689 digest_buf
[1] += SHA1M_B
;
5690 digest_buf
[2] += SHA1M_C
;
5691 digest_buf
[3] += SHA1M_D
;
5692 digest_buf
[4] += SHA1M_E
;
5695 case HASH_TYPE_SHA256
:
5696 digest_buf
[0] += SHA256M_A
;
5697 digest_buf
[1] += SHA256M_B
;
5698 digest_buf
[2] += SHA256M_C
;
5699 digest_buf
[3] += SHA256M_D
;
5700 digest_buf
[4] += SHA256M_E
;
5701 digest_buf
[5] += SHA256M_F
;
5702 digest_buf
[6] += SHA256M_G
;
5703 digest_buf
[7] += SHA256M_H
;
5706 case HASH_TYPE_SHA384
:
5707 digest_buf64
[0] += SHA384M_A
;
5708 digest_buf64
[1] += SHA384M_B
;
5709 digest_buf64
[2] += SHA384M_C
;
5710 digest_buf64
[3] += SHA384M_D
;
5711 digest_buf64
[4] += SHA384M_E
;
5712 digest_buf64
[5] += SHA384M_F
;
5713 digest_buf64
[6] += 0;
5714 digest_buf64
[7] += 0;
5717 case HASH_TYPE_SHA512
:
5718 digest_buf64
[0] += SHA512M_A
;
5719 digest_buf64
[1] += SHA512M_B
;
5720 digest_buf64
[2] += SHA512M_C
;
5721 digest_buf64
[3] += SHA512M_D
;
5722 digest_buf64
[4] += SHA512M_E
;
5723 digest_buf64
[5] += SHA512M_F
;
5724 digest_buf64
[6] += SHA512M_G
;
5725 digest_buf64
[7] += SHA512M_H
;
5730 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5732 if (dgst_size
== DGST_SIZE_4_2
)
5734 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5736 else if (dgst_size
== DGST_SIZE_4_4
)
5738 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5740 else if (dgst_size
== DGST_SIZE_4_5
)
5742 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5744 else if (dgst_size
== DGST_SIZE_4_6
)
5746 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5748 else if (dgst_size
== DGST_SIZE_4_8
)
5750 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5752 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5754 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5756 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5758 else if (hash_type
== HASH_TYPE_SHA384
)
5760 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5762 else if (hash_type
== HASH_TYPE_SHA512
)
5764 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5766 else if (hash_type
== HASH_TYPE_GOST
)
5768 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5771 else if (dgst_size
== DGST_SIZE_4_64
)
5773 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5775 else if (dgst_size
== DGST_SIZE_8_25
)
5777 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5781 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5782 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5783 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5789 memset (&salt
, 0, sizeof (salt_t
));
5791 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5793 char *ptr
= (char *) salt
.salt_buf
;
5795 uint len
= salt
.salt_len
;
5797 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5803 case HASH_TYPE_NETNTLM
:
5805 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5806 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5808 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5814 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5816 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5824 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5826 uint max
= salt
.salt_len
/ 4;
5830 for (uint i
= 0; i
< max
; i
++)
5832 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5836 if (opts_type
& OPTS_TYPE_ST_HEX
)
5840 memset (tmp
, 0, sizeof (tmp
));
5842 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5844 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5849 memcpy (ptr
, tmp
, len
);
5852 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5854 memset (ptr
+ len
, 0, memset_size
);
5856 salt
.salt_len
= len
;
5860 // some modes require special encoding
5863 uint out_buf_plain
[256];
5864 uint out_buf_salt
[256];
5868 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5869 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5871 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5873 char *ptr_plain
= (char *) out_buf_plain
;
5874 char *ptr_salt
= (char *) out_buf_salt
;
5876 if (hash_mode
== 22)
5880 memset (username
, 0, sizeof (username
));
5882 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5884 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5886 uint16_t *ptr
= (uint16_t *) digest_buf
;
5888 tmp_buf
[ 0] = sig
[0];
5889 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5890 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5891 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5892 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5893 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5894 tmp_buf
[ 6] = sig
[1];
5895 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5896 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5897 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5898 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5899 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5900 tmp_buf
[12] = sig
[2];
5901 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5902 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5903 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5904 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5905 tmp_buf
[17] = sig
[3];
5906 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5907 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5908 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5909 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5910 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5911 tmp_buf
[23] = sig
[4];
5912 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5913 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5914 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5915 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5916 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5917 tmp_buf
[29] = sig
[5];
5919 snprintf (out_buf
, len
-1, "%s:%s",
5923 else if (hash_mode
== 23)
5925 // do not show the \nskyper\n part in output
5927 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5929 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5931 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5938 else if (hash_mode
== 101)
5940 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5942 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5943 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5944 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5945 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5946 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5948 memcpy (tmp_buf
, digest_buf
, 20);
5950 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5952 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5954 else if (hash_mode
== 111)
5956 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5958 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5959 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5960 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5961 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5962 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5964 memcpy (tmp_buf
, digest_buf
, 20);
5965 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5967 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5969 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
5971 else if (hash_mode
== 122)
5973 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
5974 (unsigned char *) salt
.salt_buf
,
5981 else if (hash_mode
== 124)
5983 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
5984 (unsigned char *) salt
.salt_buf
,
5991 else if (hash_mode
== 131)
5993 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
5994 (unsigned char *) salt
.salt_buf
,
6002 else if (hash_mode
== 132)
6004 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6005 (unsigned char *) salt
.salt_buf
,
6012 else if (hash_mode
== 133)
6014 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6016 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6017 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6018 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6019 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6020 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6022 memcpy (tmp_buf
, digest_buf
, 20);
6024 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6026 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6028 else if (hash_mode
== 141)
6030 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6032 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6034 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6036 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6038 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6039 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6040 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6041 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6042 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6044 memcpy (tmp_buf
, digest_buf
, 20);
6046 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6050 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6052 else if (hash_mode
== 400)
6054 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6056 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6057 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6058 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6059 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6061 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6063 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6065 else if (hash_mode
== 500)
6067 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6074 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6076 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6078 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6082 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6085 else if (hash_mode
== 501)
6087 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6089 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6090 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6092 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6094 else if (hash_mode
== 1421)
6096 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6098 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6114 else if (hash_mode
== 1441)
6116 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6118 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6120 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6122 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6124 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6125 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6126 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6127 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6128 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6129 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6130 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6131 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6133 memcpy (tmp_buf
, digest_buf
, 32);
6135 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6139 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6141 else if (hash_mode
== 1500)
6143 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6144 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6145 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6146 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6147 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6149 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6151 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6153 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6154 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6156 memcpy (tmp_buf
, digest_buf
, 8);
6158 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6160 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6164 else if (hash_mode
== 1600)
6166 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6168 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6169 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6170 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6171 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6173 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6175 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6177 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6181 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6184 else if (hash_mode
== 1711)
6186 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6188 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6189 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6190 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6191 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6192 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6193 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6194 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6195 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6197 memcpy (tmp_buf
, digest_buf
, 64);
6198 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6200 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6202 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6204 else if (hash_mode
== 1722)
6206 uint
*ptr
= digest_buf
;
6208 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6209 (unsigned char *) salt
.salt_buf
,
6219 else if (hash_mode
== 1731)
6221 uint
*ptr
= digest_buf
;
6223 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6224 (unsigned char *) salt
.salt_buf
,
6234 else if (hash_mode
== 1800)
6238 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6239 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6240 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6241 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6242 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6243 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6244 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6245 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6247 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6249 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6251 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6255 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6258 else if (hash_mode
== 2100)
6262 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6264 salt
.salt_iter
+ 1);
6266 uint signature_len
= strlen (out_buf
);
6268 pos
+= signature_len
;
6269 len
-= signature_len
;
6271 char *salt_ptr
= (char *) salt
.salt_buf
;
6273 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6275 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6276 byte_swap_32 (digest_buf
[0]),
6277 byte_swap_32 (digest_buf
[1]),
6278 byte_swap_32 (digest_buf
[2]),
6279 byte_swap_32 (digest_buf
[3]));
6281 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6283 memcpy (tmp_buf
, digest_buf
, 16);
6285 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6287 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6288 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6289 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6290 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6292 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6293 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6294 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6295 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6297 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6298 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6299 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6300 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6302 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6303 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6304 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6305 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6307 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6308 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6309 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6310 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6314 else if (hash_mode
== 2500)
6316 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6318 wpa_t
*wpa
= &wpas
[salt_pos
];
6322 char *pke_ptr
= (char *) pke
;
6324 for (uint i
= 0; i
< 25; i
++)
6326 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6329 unsigned char mac1
[6];
6330 unsigned char mac2
[6];
6332 memcpy (mac1
, pke_ptr
+ 23, 6);
6333 memcpy (mac2
, pke_ptr
+ 29, 6);
6335 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6336 (char *) salt
.salt_buf
,
6350 else if (hash_mode
== 4400)
6352 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6353 byte_swap_32 (digest_buf
[0]),
6354 byte_swap_32 (digest_buf
[1]),
6355 byte_swap_32 (digest_buf
[2]),
6356 byte_swap_32 (digest_buf
[3]));
6358 else if (hash_mode
== 4700)
6360 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6361 byte_swap_32 (digest_buf
[0]),
6362 byte_swap_32 (digest_buf
[1]),
6363 byte_swap_32 (digest_buf
[2]),
6364 byte_swap_32 (digest_buf
[3]),
6365 byte_swap_32 (digest_buf
[4]));
6367 else if (hash_mode
== 4800)
6369 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6376 byte_swap_32 (salt
.salt_buf
[0]),
6377 byte_swap_32 (salt
.salt_buf
[1]),
6378 byte_swap_32 (salt
.salt_buf
[2]),
6379 byte_swap_32 (salt
.salt_buf
[3]),
6382 else if (hash_mode
== 4900)
6384 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6385 byte_swap_32 (digest_buf
[0]),
6386 byte_swap_32 (digest_buf
[1]),
6387 byte_swap_32 (digest_buf
[2]),
6388 byte_swap_32 (digest_buf
[3]),
6389 byte_swap_32 (digest_buf
[4]));
6391 else if (hash_mode
== 5100)
6393 snprintf (out_buf
, len
-1, "%08x%08x",
6397 else if (hash_mode
== 5200)
6399 snprintf (out_buf
, len
-1, "%s", hashfile
);
6401 else if (hash_mode
== 5300)
6403 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6405 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6407 int buf_len
= len
-1;
6411 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6413 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6415 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6417 snprintf (out_buf
, buf_len
, ":");
6423 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6431 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6433 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6435 if ((i
== 0) || (i
== 5))
6437 snprintf (out_buf
, buf_len
, ":");
6443 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6451 for (uint i
= 0; i
< 4; i
++)
6455 snprintf (out_buf
, buf_len
, ":");
6461 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6467 else if (hash_mode
== 5400)
6469 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6471 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6473 int buf_len
= len
-1;
6477 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6479 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6481 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6483 snprintf (out_buf
, buf_len
, ":");
6489 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6497 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6499 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6501 if ((i
== 0) || (i
== 5))
6503 snprintf (out_buf
, buf_len
, ":");
6509 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6517 for (uint i
= 0; i
< 5; i
++)
6521 snprintf (out_buf
, buf_len
, ":");
6527 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6533 else if (hash_mode
== 5500)
6535 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6537 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6540 char domain_buf
[64];
6541 char srvchall_buf
[1024];
6542 char clichall_buf
[1024];
6544 memset (user_buf
, 0, sizeof (user_buf
));
6545 memset (domain_buf
, 0, sizeof (domain_buf
));
6546 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6547 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6549 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6551 char *ptr
= (char *) netntlm
->userdomain_buf
;
6553 user_buf
[i
] = ptr
[j
];
6556 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6558 char *ptr
= (char *) netntlm
->userdomain_buf
;
6560 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6563 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6565 char *ptr
= (char *) netntlm
->chall_buf
;
6567 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6570 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6572 char *ptr
= (char *) netntlm
->chall_buf
;
6574 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6577 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6585 byte_swap_32 (salt
.salt_buf_pc
[0]),
6586 byte_swap_32 (salt
.salt_buf_pc
[1]),
6589 else if (hash_mode
== 5600)
6591 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6593 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6596 char domain_buf
[64];
6597 char srvchall_buf
[1024];
6598 char clichall_buf
[1024];
6600 memset (user_buf
, 0, sizeof (user_buf
));
6601 memset (domain_buf
, 0, sizeof (domain_buf
));
6602 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6603 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6605 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6607 char *ptr
= (char *) netntlm
->userdomain_buf
;
6609 user_buf
[i
] = ptr
[j
];
6612 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6614 char *ptr
= (char *) netntlm
->userdomain_buf
;
6616 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6619 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6621 char *ptr
= (char *) netntlm
->chall_buf
;
6623 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6626 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6628 char *ptr
= (char *) netntlm
->chall_buf
;
6630 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6633 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6643 else if (hash_mode
== 5700)
6645 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6647 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6648 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6649 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6650 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6651 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6652 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6653 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6654 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6656 memcpy (tmp_buf
, digest_buf
, 32);
6658 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6662 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6664 else if (hash_mode
== 5800)
6666 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6667 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6668 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6669 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6670 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6672 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6679 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6681 snprintf (out_buf
, len
-1, "%s", hashfile
);
6683 else if (hash_mode
== 6300)
6685 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6687 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6688 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6689 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6690 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6692 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6694 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6696 else if (hash_mode
== 6400)
6698 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6700 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6702 else if (hash_mode
== 6500)
6704 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6706 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6708 else if (hash_mode
== 6600)
6710 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6712 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6714 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6715 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6717 uint buf_len
= len
- 1;
6719 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6722 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6724 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6729 else if (hash_mode
== 6700)
6731 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6733 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6735 else if (hash_mode
== 6800)
6737 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6739 else if (hash_mode
== 7100)
6741 uint
*ptr
= digest_buf
;
6743 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6745 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6749 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6750 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6751 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6752 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6753 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6754 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6755 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6756 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6758 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",
6759 SIGNATURE_SHA512OSX
,
6761 esalt
[ 0], esalt
[ 1],
6762 esalt
[ 2], esalt
[ 3],
6763 esalt
[ 4], esalt
[ 5],
6764 esalt
[ 6], esalt
[ 7],
6772 ptr
[15], ptr
[14]);
6774 else if (hash_mode
== 7200)
6776 uint
*ptr
= digest_buf
;
6778 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6780 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6784 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6786 len_used
= strlen (out_buf
);
6788 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6790 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6792 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6795 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",
6803 ptr
[15], ptr
[14]);
6805 else if (hash_mode
== 7300)
6807 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6809 rakp_t
*rakp
= &rakps
[salt_pos
];
6811 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6813 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6816 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6823 else if (hash_mode
== 7400)
6825 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6827 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6828 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6829 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6830 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6831 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6832 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6833 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6834 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6836 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6838 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6840 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6844 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6847 else if (hash_mode
== 7500)
6849 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6851 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6853 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6854 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6858 char *ptr_data
= data
;
6860 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6862 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6865 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6867 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6872 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6874 (char *) krb5pa
->user
,
6875 (char *) krb5pa
->realm
,
6876 (char *) krb5pa
->salt
,
6879 else if (hash_mode
== 7700)
6881 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6882 (char *) salt
.salt_buf
,
6886 else if (hash_mode
== 7800)
6888 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6889 (char *) salt
.salt_buf
,
6896 else if (hash_mode
== 7900)
6898 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6902 char *tmp
= (char *) salt
.salt_buf_pc
;
6904 ptr_plain
[42] = tmp
[0];
6910 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6912 else if (hash_mode
== 8000)
6914 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6915 (unsigned char *) salt
.salt_buf
,
6925 else if (hash_mode
== 8100)
6927 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6928 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6930 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6931 (unsigned char *) salt
.salt_buf
,
6938 else if (hash_mode
== 8200)
6940 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6942 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6944 char data_buf
[4096];
6946 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6948 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6951 data_buf
[cloudkey
->data_len
* 2] = 0;
6953 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6954 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6955 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6956 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6957 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6958 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6959 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6960 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6962 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6963 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6964 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6965 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6967 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
6983 else if (hash_mode
== 8300)
6987 char digest_buf_c
[33];
6989 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
6991 digest_buf_c
[32] = 0;
6995 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
6997 char domain_buf_c
[33];
6999 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7001 for (uint i
= 0; i
< salt_pc_len
; i
++)
7003 const char next
= domain_buf_c
[i
];
7005 domain_buf_c
[i
] = '.';
7010 domain_buf_c
[salt_pc_len
] = 0;
7014 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7016 else if (hash_mode
== 8500)
7018 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7020 else if (hash_mode
== 2612)
7022 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7024 (char *) salt
.salt_buf
,
7030 else if (hash_mode
== 3711)
7032 char *salt_ptr
= (char *) salt
.salt_buf
;
7034 salt_ptr
[salt
.salt_len
- 1] = 0;
7036 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7037 SIGNATURE_MEDIAWIKI_B
,
7044 else if (hash_mode
== 8800)
7046 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7048 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7052 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7054 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7059 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7060 SIGNATURE_ANDROIDFDE
,
7061 byte_swap_32 (salt
.salt_buf
[0]),
7062 byte_swap_32 (salt
.salt_buf
[1]),
7063 byte_swap_32 (salt
.salt_buf
[2]),
7064 byte_swap_32 (salt
.salt_buf
[3]),
7065 byte_swap_32 (digest_buf
[0]),
7066 byte_swap_32 (digest_buf
[1]),
7067 byte_swap_32 (digest_buf
[2]),
7068 byte_swap_32 (digest_buf
[3]),
7071 else if (hash_mode
== 8900)
7073 uint N
= salt
.scrypt_N
;
7074 uint r
= salt
.scrypt_r
;
7075 uint p
= salt
.scrypt_p
;
7077 char base64_salt
[32];
7079 memset (base64_salt
, 0, 32);
7081 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7083 memset (tmp_buf
, 0, 46);
7085 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7086 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7087 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7088 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7089 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7090 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7091 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7092 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7093 digest_buf
[8] = 0; // needed for base64_encode ()
7095 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7097 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7105 else if (hash_mode
== 9000)
7107 snprintf (out_buf
, len
-1, "%s", hashfile
);
7109 else if (hash_mode
== 9200)
7113 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7115 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7117 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7123 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7124 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7125 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7126 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7127 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7128 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7129 digest_buf
[8] = 0; // needed for base64_encode ()
7132 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7134 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7135 tmp_buf
[43] = 0; // cut it here
7139 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7141 else if (hash_mode
== 9300)
7143 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7144 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7145 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7146 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7147 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7148 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7149 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7150 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7151 digest_buf
[8] = 0; // needed for base64_encode ()
7154 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7156 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7157 tmp_buf
[43] = 0; // cut it here
7159 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7161 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7163 else if (hash_mode
== 9400)
7165 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7167 office2007_t
*office2007
= &office2007s
[salt_pos
];
7169 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7170 SIGNATURE_OFFICE2007
,
7173 office2007
->keySize
,
7179 office2007
->encryptedVerifier
[0],
7180 office2007
->encryptedVerifier
[1],
7181 office2007
->encryptedVerifier
[2],
7182 office2007
->encryptedVerifier
[3],
7183 office2007
->encryptedVerifierHash
[0],
7184 office2007
->encryptedVerifierHash
[1],
7185 office2007
->encryptedVerifierHash
[2],
7186 office2007
->encryptedVerifierHash
[3],
7187 office2007
->encryptedVerifierHash
[4]);
7189 else if (hash_mode
== 9500)
7191 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7193 office2010_t
*office2010
= &office2010s
[salt_pos
];
7195 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,
7201 office2010
->encryptedVerifier
[0],
7202 office2010
->encryptedVerifier
[1],
7203 office2010
->encryptedVerifier
[2],
7204 office2010
->encryptedVerifier
[3],
7205 office2010
->encryptedVerifierHash
[0],
7206 office2010
->encryptedVerifierHash
[1],
7207 office2010
->encryptedVerifierHash
[2],
7208 office2010
->encryptedVerifierHash
[3],
7209 office2010
->encryptedVerifierHash
[4],
7210 office2010
->encryptedVerifierHash
[5],
7211 office2010
->encryptedVerifierHash
[6],
7212 office2010
->encryptedVerifierHash
[7]);
7214 else if (hash_mode
== 9600)
7216 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7218 office2013_t
*office2013
= &office2013s
[salt_pos
];
7220 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,
7226 office2013
->encryptedVerifier
[0],
7227 office2013
->encryptedVerifier
[1],
7228 office2013
->encryptedVerifier
[2],
7229 office2013
->encryptedVerifier
[3],
7230 office2013
->encryptedVerifierHash
[0],
7231 office2013
->encryptedVerifierHash
[1],
7232 office2013
->encryptedVerifierHash
[2],
7233 office2013
->encryptedVerifierHash
[3],
7234 office2013
->encryptedVerifierHash
[4],
7235 office2013
->encryptedVerifierHash
[5],
7236 office2013
->encryptedVerifierHash
[6],
7237 office2013
->encryptedVerifierHash
[7]);
7239 else if (hash_mode
== 9700)
7241 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7243 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7245 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7246 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7247 byte_swap_32 (salt
.salt_buf
[0]),
7248 byte_swap_32 (salt
.salt_buf
[1]),
7249 byte_swap_32 (salt
.salt_buf
[2]),
7250 byte_swap_32 (salt
.salt_buf
[3]),
7251 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7252 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7253 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7254 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7255 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7256 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7257 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7258 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7260 else if (hash_mode
== 9710)
7262 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7264 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7266 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7267 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7268 byte_swap_32 (salt
.salt_buf
[0]),
7269 byte_swap_32 (salt
.salt_buf
[1]),
7270 byte_swap_32 (salt
.salt_buf
[2]),
7271 byte_swap_32 (salt
.salt_buf
[3]),
7272 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7273 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7274 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7275 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7276 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7277 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7278 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7279 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7281 else if (hash_mode
== 9720)
7283 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7285 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7287 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7289 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7290 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7291 byte_swap_32 (salt
.salt_buf
[0]),
7292 byte_swap_32 (salt
.salt_buf
[1]),
7293 byte_swap_32 (salt
.salt_buf
[2]),
7294 byte_swap_32 (salt
.salt_buf
[3]),
7295 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7296 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7297 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7298 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7299 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7300 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7301 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7302 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7309 else if (hash_mode
== 9800)
7311 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7313 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7315 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7316 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7321 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7322 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7323 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7324 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7325 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7326 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7327 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7328 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7329 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7331 else if (hash_mode
== 9810)
7333 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7335 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7337 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7338 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7343 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7344 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7345 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7346 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7347 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7348 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7349 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7350 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7351 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7353 else if (hash_mode
== 9820)
7355 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7357 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7359 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7361 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7362 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7367 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7368 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7369 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7370 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7371 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7372 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7373 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7374 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7375 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7382 else if (hash_mode
== 10000)
7386 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7388 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7390 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7394 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7395 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7396 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7397 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7398 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7399 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7400 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7401 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7402 digest_buf
[8] = 0; // needed for base64_encode ()
7405 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7407 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7411 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7413 else if (hash_mode
== 10100)
7415 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7420 byte_swap_32 (salt
.salt_buf
[0]),
7421 byte_swap_32 (salt
.salt_buf
[1]),
7422 byte_swap_32 (salt
.salt_buf
[2]),
7423 byte_swap_32 (salt
.salt_buf
[3]));
7425 else if (hash_mode
== 10200)
7427 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7429 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7433 char challenge
[100];
7435 memset (challenge
, 0, sizeof (challenge
));
7437 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7443 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7444 (char *) cram_md5
->user
,
7452 memset (response
, 0, sizeof (response
));
7454 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7456 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7458 else if (hash_mode
== 10300)
7462 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7464 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7465 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7467 uint tmp_len
= 20 + salt
.salt_len
;
7471 char base64_encoded
[100];
7473 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7475 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7477 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7479 else if (hash_mode
== 10400)
7481 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7483 pdf_t
*pdf
= &pdfs
[salt_pos
];
7485 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",
7493 byte_swap_32 (pdf
->id_buf
[0]),
7494 byte_swap_32 (pdf
->id_buf
[1]),
7495 byte_swap_32 (pdf
->id_buf
[2]),
7496 byte_swap_32 (pdf
->id_buf
[3]),
7498 byte_swap_32 (pdf
->u_buf
[0]),
7499 byte_swap_32 (pdf
->u_buf
[1]),
7500 byte_swap_32 (pdf
->u_buf
[2]),
7501 byte_swap_32 (pdf
->u_buf
[3]),
7502 byte_swap_32 (pdf
->u_buf
[4]),
7503 byte_swap_32 (pdf
->u_buf
[5]),
7504 byte_swap_32 (pdf
->u_buf
[6]),
7505 byte_swap_32 (pdf
->u_buf
[7]),
7507 byte_swap_32 (pdf
->o_buf
[0]),
7508 byte_swap_32 (pdf
->o_buf
[1]),
7509 byte_swap_32 (pdf
->o_buf
[2]),
7510 byte_swap_32 (pdf
->o_buf
[3]),
7511 byte_swap_32 (pdf
->o_buf
[4]),
7512 byte_swap_32 (pdf
->o_buf
[5]),
7513 byte_swap_32 (pdf
->o_buf
[6]),
7514 byte_swap_32 (pdf
->o_buf
[7])
7517 else if (hash_mode
== 10410)
7519 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7521 pdf_t
*pdf
= &pdfs
[salt_pos
];
7523 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",
7531 byte_swap_32 (pdf
->id_buf
[0]),
7532 byte_swap_32 (pdf
->id_buf
[1]),
7533 byte_swap_32 (pdf
->id_buf
[2]),
7534 byte_swap_32 (pdf
->id_buf
[3]),
7536 byte_swap_32 (pdf
->u_buf
[0]),
7537 byte_swap_32 (pdf
->u_buf
[1]),
7538 byte_swap_32 (pdf
->u_buf
[2]),
7539 byte_swap_32 (pdf
->u_buf
[3]),
7540 byte_swap_32 (pdf
->u_buf
[4]),
7541 byte_swap_32 (pdf
->u_buf
[5]),
7542 byte_swap_32 (pdf
->u_buf
[6]),
7543 byte_swap_32 (pdf
->u_buf
[7]),
7545 byte_swap_32 (pdf
->o_buf
[0]),
7546 byte_swap_32 (pdf
->o_buf
[1]),
7547 byte_swap_32 (pdf
->o_buf
[2]),
7548 byte_swap_32 (pdf
->o_buf
[3]),
7549 byte_swap_32 (pdf
->o_buf
[4]),
7550 byte_swap_32 (pdf
->o_buf
[5]),
7551 byte_swap_32 (pdf
->o_buf
[6]),
7552 byte_swap_32 (pdf
->o_buf
[7])
7555 else if (hash_mode
== 10420)
7557 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7559 pdf_t
*pdf
= &pdfs
[salt_pos
];
7561 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7563 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",
7571 byte_swap_32 (pdf
->id_buf
[0]),
7572 byte_swap_32 (pdf
->id_buf
[1]),
7573 byte_swap_32 (pdf
->id_buf
[2]),
7574 byte_swap_32 (pdf
->id_buf
[3]),
7576 byte_swap_32 (pdf
->u_buf
[0]),
7577 byte_swap_32 (pdf
->u_buf
[1]),
7578 byte_swap_32 (pdf
->u_buf
[2]),
7579 byte_swap_32 (pdf
->u_buf
[3]),
7580 byte_swap_32 (pdf
->u_buf
[4]),
7581 byte_swap_32 (pdf
->u_buf
[5]),
7582 byte_swap_32 (pdf
->u_buf
[6]),
7583 byte_swap_32 (pdf
->u_buf
[7]),
7585 byte_swap_32 (pdf
->o_buf
[0]),
7586 byte_swap_32 (pdf
->o_buf
[1]),
7587 byte_swap_32 (pdf
->o_buf
[2]),
7588 byte_swap_32 (pdf
->o_buf
[3]),
7589 byte_swap_32 (pdf
->o_buf
[4]),
7590 byte_swap_32 (pdf
->o_buf
[5]),
7591 byte_swap_32 (pdf
->o_buf
[6]),
7592 byte_swap_32 (pdf
->o_buf
[7]),
7600 else if (hash_mode
== 10500)
7602 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7604 pdf_t
*pdf
= &pdfs
[salt_pos
];
7606 if (pdf
->id_len
== 32)
7608 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",
7616 byte_swap_32 (pdf
->id_buf
[0]),
7617 byte_swap_32 (pdf
->id_buf
[1]),
7618 byte_swap_32 (pdf
->id_buf
[2]),
7619 byte_swap_32 (pdf
->id_buf
[3]),
7620 byte_swap_32 (pdf
->id_buf
[4]),
7621 byte_swap_32 (pdf
->id_buf
[5]),
7622 byte_swap_32 (pdf
->id_buf
[6]),
7623 byte_swap_32 (pdf
->id_buf
[7]),
7625 byte_swap_32 (pdf
->u_buf
[0]),
7626 byte_swap_32 (pdf
->u_buf
[1]),
7627 byte_swap_32 (pdf
->u_buf
[2]),
7628 byte_swap_32 (pdf
->u_buf
[3]),
7629 byte_swap_32 (pdf
->u_buf
[4]),
7630 byte_swap_32 (pdf
->u_buf
[5]),
7631 byte_swap_32 (pdf
->u_buf
[6]),
7632 byte_swap_32 (pdf
->u_buf
[7]),
7634 byte_swap_32 (pdf
->o_buf
[0]),
7635 byte_swap_32 (pdf
->o_buf
[1]),
7636 byte_swap_32 (pdf
->o_buf
[2]),
7637 byte_swap_32 (pdf
->o_buf
[3]),
7638 byte_swap_32 (pdf
->o_buf
[4]),
7639 byte_swap_32 (pdf
->o_buf
[5]),
7640 byte_swap_32 (pdf
->o_buf
[6]),
7641 byte_swap_32 (pdf
->o_buf
[7])
7646 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",
7654 byte_swap_32 (pdf
->id_buf
[0]),
7655 byte_swap_32 (pdf
->id_buf
[1]),
7656 byte_swap_32 (pdf
->id_buf
[2]),
7657 byte_swap_32 (pdf
->id_buf
[3]),
7659 byte_swap_32 (pdf
->u_buf
[0]),
7660 byte_swap_32 (pdf
->u_buf
[1]),
7661 byte_swap_32 (pdf
->u_buf
[2]),
7662 byte_swap_32 (pdf
->u_buf
[3]),
7663 byte_swap_32 (pdf
->u_buf
[4]),
7664 byte_swap_32 (pdf
->u_buf
[5]),
7665 byte_swap_32 (pdf
->u_buf
[6]),
7666 byte_swap_32 (pdf
->u_buf
[7]),
7668 byte_swap_32 (pdf
->o_buf
[0]),
7669 byte_swap_32 (pdf
->o_buf
[1]),
7670 byte_swap_32 (pdf
->o_buf
[2]),
7671 byte_swap_32 (pdf
->o_buf
[3]),
7672 byte_swap_32 (pdf
->o_buf
[4]),
7673 byte_swap_32 (pdf
->o_buf
[5]),
7674 byte_swap_32 (pdf
->o_buf
[6]),
7675 byte_swap_32 (pdf
->o_buf
[7])
7679 else if (hash_mode
== 10600)
7681 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7683 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7684 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7686 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7688 else if (hash_mode
== 10700)
7690 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7692 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7693 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7695 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7697 else if (hash_mode
== 10900)
7699 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7701 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7702 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7704 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7706 else if (hash_mode
== 11100)
7708 uint32_t salt_challenge
= salt
.salt_buf
[0];
7710 salt_challenge
= byte_swap_32 (salt_challenge
);
7712 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7714 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7715 SIGNATURE_POSTGRESQL_AUTH
,
7723 else if (hash_mode
== 11200)
7725 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7726 SIGNATURE_MYSQL_AUTH
,
7727 (unsigned char *) salt
.salt_buf
,
7734 else if (hash_mode
== 11300)
7736 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7738 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7740 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7741 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7742 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7744 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7745 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7746 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7748 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7750 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7752 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7755 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7757 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7759 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7762 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7764 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7766 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7769 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7770 SIGNATURE_BITCOIN_WALLET
,
7774 (unsigned char *) salt
.salt_buf
,
7782 free (cry_master_buf
);
7784 free (public_key_buf
);
7786 else if (hash_mode
== 11400)
7788 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7790 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7791 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7793 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7795 else if (hash_mode
== 11600)
7797 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7799 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7801 const uint data_len
= seven_zip
->data_len
;
7803 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7805 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7807 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7809 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7812 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7813 SIGNATURE_SEVEN_ZIP
,
7817 (char *) seven_zip
->salt_buf
,
7819 seven_zip
->iv_buf
[0],
7820 seven_zip
->iv_buf
[1],
7821 seven_zip
->iv_buf
[2],
7822 seven_zip
->iv_buf
[3],
7824 seven_zip
->data_len
,
7825 seven_zip
->unpack_size
,
7830 else if (hash_mode
== 11700)
7832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7842 else if (hash_mode
== 11800)
7844 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7862 else if (hash_mode
== 11900)
7864 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7866 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7867 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7869 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7871 else if (hash_mode
== 12000)
7873 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7875 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7876 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7878 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7880 else if (hash_mode
== 12100)
7882 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7884 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7885 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7887 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7889 else if (hash_mode
== 12200)
7891 uint
*ptr_digest
= digest_buf
;
7892 uint
*ptr_salt
= salt
.salt_buf
;
7894 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7901 else if (hash_mode
== 12300)
7903 uint
*ptr_digest
= digest_buf
;
7904 uint
*ptr_salt
= salt
.salt_buf
;
7906 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",
7907 ptr_digest
[ 0], ptr_digest
[ 1],
7908 ptr_digest
[ 2], ptr_digest
[ 3],
7909 ptr_digest
[ 4], ptr_digest
[ 5],
7910 ptr_digest
[ 6], ptr_digest
[ 7],
7911 ptr_digest
[ 8], ptr_digest
[ 9],
7912 ptr_digest
[10], ptr_digest
[11],
7913 ptr_digest
[12], ptr_digest
[13],
7914 ptr_digest
[14], ptr_digest
[15],
7920 else if (hash_mode
== 12400)
7922 // encode iteration count
7926 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7927 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7928 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7929 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7934 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7935 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7936 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7937 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7942 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7944 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7945 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7947 memcpy (tmp_buf
, digest_buf
, 8);
7949 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7953 // fill the resulting buffer
7955 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7957 else if (hash_mode
== 12500)
7959 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7961 byte_swap_32 (salt
.salt_buf
[0]),
7962 byte_swap_32 (salt
.salt_buf
[1]),
7968 else if (hash_mode
== 12600)
7970 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7971 digest_buf
[0] + salt
.salt_buf_pc
[0],
7972 digest_buf
[1] + salt
.salt_buf_pc
[1],
7973 digest_buf
[2] + salt
.salt_buf_pc
[2],
7974 digest_buf
[3] + salt
.salt_buf_pc
[3],
7975 digest_buf
[4] + salt
.salt_buf_pc
[4],
7976 digest_buf
[5] + salt
.salt_buf_pc
[5],
7977 digest_buf
[6] + salt
.salt_buf_pc
[6],
7978 digest_buf
[7] + salt
.salt_buf_pc
[7]);
7980 else if (hash_mode
== 12700)
7982 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7984 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7985 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7987 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7989 else if (hash_mode
== 12800)
7991 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
7993 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",
8006 byte_swap_32 (digest_buf
[0]),
8007 byte_swap_32 (digest_buf
[1]),
8008 byte_swap_32 (digest_buf
[2]),
8009 byte_swap_32 (digest_buf
[3]),
8010 byte_swap_32 (digest_buf
[4]),
8011 byte_swap_32 (digest_buf
[5]),
8012 byte_swap_32 (digest_buf
[6]),
8013 byte_swap_32 (digest_buf
[7])
8018 if (hash_type
== HASH_TYPE_MD4
)
8020 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8026 else if (hash_type
== HASH_TYPE_MD5
)
8028 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8034 else if (hash_type
== HASH_TYPE_SHA1
)
8036 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8043 else if (hash_type
== HASH_TYPE_SHA256
)
8045 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8055 else if (hash_type
== HASH_TYPE_SHA384
)
8057 uint
*ptr
= digest_buf
;
8059 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8067 else if (hash_type
== HASH_TYPE_SHA512
)
8069 uint
*ptr
= digest_buf
;
8071 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8081 else if (hash_type
== HASH_TYPE_LM
)
8083 snprintf (out_buf
, len
-1, "%08x%08x",
8087 else if (hash_type
== HASH_TYPE_ORACLEH
)
8089 snprintf (out_buf
, len
-1, "%08X%08X",
8093 else if (hash_type
== HASH_TYPE_BCRYPT
)
8095 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8096 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8098 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8100 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8102 else if (hash_type
== HASH_TYPE_KECCAK
)
8104 uint
*ptr
= digest_buf
;
8106 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",
8134 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8136 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8138 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8145 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8147 digest_buf
[ 0] = digest_buf
[ 0];
8148 digest_buf
[ 1] = digest_buf
[ 1];
8149 digest_buf
[ 2] = digest_buf
[ 2];
8150 digest_buf
[ 3] = digest_buf
[ 3];
8151 digest_buf
[ 4] = digest_buf
[ 4];
8152 digest_buf
[ 5] = digest_buf
[ 5];
8153 digest_buf
[ 6] = digest_buf
[ 6];
8154 digest_buf
[ 7] = digest_buf
[ 7];
8155 digest_buf
[ 8] = digest_buf
[ 8];
8156 digest_buf
[ 9] = digest_buf
[ 9];
8157 digest_buf
[10] = digest_buf
[10];
8158 digest_buf
[11] = digest_buf
[11];
8159 digest_buf
[12] = digest_buf
[12];
8160 digest_buf
[13] = digest_buf
[13];
8161 digest_buf
[14] = digest_buf
[14];
8162 digest_buf
[15] = digest_buf
[15];
8164 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8182 else if (hash_type
== HASH_TYPE_GOST
)
8184 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8194 else if (hash_type
== HASH_TYPE_MYSQL
)
8196 snprintf (out_buf
, len
-1, "%08x%08x",
8200 else if (hash_type
== HASH_TYPE_LOTUS5
)
8202 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8208 else if (hash_type
== HASH_TYPE_LOTUS6
)
8210 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8211 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8212 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8213 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8217 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8218 memcpy (buf
+ 5, digest_buf
, 9);
8222 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8224 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8227 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8229 else if (hash_type
== HASH_TYPE_LOTUS8
)
8233 memset (buf
, 0, sizeof (buf
));
8237 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8243 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8247 buf
[26] = salt
.salt_buf_pc
[0];
8248 buf
[27] = salt
.salt_buf_pc
[1];
8252 memcpy (buf
+ 28, digest_buf
, 8);
8254 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8258 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8260 else if (hash_type
== HASH_TYPE_CRC32
)
8262 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8266 if (salt_type
== SALT_TYPE_INTERN
)
8268 size_t pos
= strlen (out_buf
);
8270 out_buf
[pos
] = data
.separator
;
8272 char *ptr
= (char *) salt
.salt_buf
;
8274 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8276 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8280 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8282 memset (hccap
, 0, sizeof (hccap_t
));
8284 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8286 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8288 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8289 wpa_t
*wpa
= &wpas
[salt_pos
];
8291 hccap
->keyver
= wpa
->keyver
;
8293 hccap
->eapol_size
= wpa
->eapol_size
;
8295 if (wpa
->keyver
!= 1)
8299 for (uint i
= 0; i
< 64; i
++)
8301 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8304 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8308 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8313 for (int i
= 5; i
< 25; i
++)
8315 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8318 char *pke_ptr
= (char *) pke_tmp
;
8320 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8321 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8322 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8323 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8325 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8327 uint dgst_size
= data
.dgst_size
;
8329 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8331 if (wpa
->keyver
!= 1)
8335 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8336 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8337 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8338 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8340 memcpy (hccap
->keymic
, digest_tmp
, 16);
8344 memcpy (hccap
->keymic
, digest_ptr
, 16);
8348 void SuspendThreads ()
8350 if (data
.devices_status
== STATUS_RUNNING
)
8352 hc_timer_set (&data
.timer_paused
);
8354 data
.devices_status
= STATUS_PAUSED
;
8356 log_info ("Paused");
8360 void ResumeThreads ()
8362 if (data
.devices_status
== STATUS_PAUSED
)
8366 hc_timer_get (data
.timer_paused
, ms_paused
);
8368 data
.ms_paused
+= ms_paused
;
8370 data
.devices_status
= STATUS_RUNNING
;
8372 log_info ("Resumed");
8378 if (data
.devices_status
!= STATUS_RUNNING
) return;
8380 data
.devices_status
= STATUS_BYPASS
;
8382 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8385 void stop_at_checkpoint ()
8387 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8389 if (data
.devices_status
!= STATUS_RUNNING
) return;
8392 // this feature only makes sense if --restore-disable was not specified
8394 if (data
.restore_disable
== 1)
8396 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8401 // check if monitoring of Restore Point updates should be enabled or disabled
8403 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8405 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8407 // save the current restore point value
8409 data
.checkpoint_cur_words
= get_lowest_words_done ();
8411 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8415 data
.devices_status
= STATUS_RUNNING
;
8417 // reset the global value for checkpoint checks
8419 data
.checkpoint_cur_words
= 0;
8421 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8427 if (data
.devices_status
== STATUS_INIT
) return;
8428 if (data
.devices_status
== STATUS_STARTING
) return;
8430 data
.devices_status
= STATUS_ABORTED
;
8435 if (data
.devices_status
== STATUS_INIT
) return;
8436 if (data
.devices_status
== STATUS_STARTING
) return;
8438 data
.devices_status
= STATUS_QUIT
;
8441 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8445 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8449 memset (&st
, 0, sizeof (st
));
8451 stat (kernel_file
, &st
);
8453 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8455 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8457 if (num_read
!= (size_t) st
.st_size
)
8459 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8466 buf
[st
.st_size
] = 0;
8468 for (int i
= 0; i
< num_devices
; i
++)
8470 kernel_lengths
[i
] = (size_t) st
.st_size
;
8472 kernel_sources
[i
] = buf
;
8477 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8485 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8487 FILE *fp
= fopen (dst
, "wb");
8489 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8499 restore_data_t
*init_restore (int argc
, char **argv
)
8501 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8503 if (data
.restore_disable
== 0)
8505 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8509 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8513 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8522 char pidbin
[BUFSIZ
];
8527 memset (pidbin
, 0, sizeof (pidbin
));
8529 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8531 FILE *fd
= fopen (pidbin
, "rb");
8535 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8537 pidbin
[pidbin_len
] = 0;
8541 char *argv0_r
= strrchr (argv
[0], '/');
8543 char *pidbin_r
= strrchr (pidbin
, '/');
8545 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8547 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8549 if (strcmp (argv0_r
, pidbin_r
) == 0)
8551 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8558 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8560 char pidbin2
[BUFSIZ
];
8564 memset (pidbin2
, 0, sizeof (pidbin2
));
8566 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8567 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8569 pidbin
[pidbin_len
] = 0;
8570 pidbin2
[pidbin2_len
] = 0;
8574 if (strcmp (pidbin
, pidbin2
) == 0)
8576 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8584 if (rd
->version_bin
< RESTORE_MIN
)
8586 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8593 memset (rd
, 0, sizeof (restore_data_t
));
8595 rd
->version_bin
= VERSION_BIN
;
8598 rd
->pid
= getpid ();
8600 rd
->pid
= GetCurrentProcessId ();
8603 if (getcwd (rd
->cwd
, 255) == NULL
)
8616 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8618 FILE *fp
= fopen (eff_restore_file
, "rb");
8622 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8627 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8629 log_error ("ERROR: cannot read %s", eff_restore_file
);
8634 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8636 for (uint i
= 0; i
< rd
->argc
; i
++)
8640 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8642 log_error ("ERROR: cannot read %s", eff_restore_file
);
8647 size_t len
= strlen (buf
);
8649 if (len
) buf
[len
- 1] = 0;
8651 rd
->argv
[i
] = mystrdup (buf
);
8658 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8662 log_error ("Restore file is corrupted");
8665 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8667 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8669 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8674 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8678 if (chdir (rd
->cwd
))
8680 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8686 uint64_t get_lowest_words_done ()
8688 uint64_t words_cur
= -1;
8690 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8692 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8694 const uint64_t words_done
= device_param
->words_done
;
8696 if (words_done
< words_cur
) words_cur
= words_done
;
8699 // It's possible that a GPU's workload isn't finished right after a restore-case.
8700 // In that case, this function would return 0 and overwrite the real restore point
8701 // There's also data.words_cur which is set to rd->words_cur but it changes while
8702 // the attack is running therefore we should stick to rd->words_cur.
8703 // Note that -s influences rd->words_cur we should keep a close look on that.
8705 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8710 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8712 uint64_t words_cur
= get_lowest_words_done ();
8714 rd
->words_cur
= words_cur
;
8716 FILE *fp
= fopen (new_restore_file
, "wb");
8720 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8725 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8727 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8732 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8734 for (uint i
= 0; i
< rd
->argc
; i
++)
8736 fprintf (fp
, "%s", rd
->argv
[i
]);
8742 fsync (fileno (fp
));
8747 void cycle_restore ()
8749 const char *eff_restore_file
= data
.eff_restore_file
;
8750 const char *new_restore_file
= data
.new_restore_file
;
8752 restore_data_t
*rd
= data
.rd
;
8754 write_restore (new_restore_file
, rd
);
8758 memset (&st
, 0, sizeof(st
));
8760 if (stat (eff_restore_file
, &st
) == 0)
8762 if (unlink (eff_restore_file
))
8764 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8768 if (rename (new_restore_file
, eff_restore_file
))
8770 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8774 void check_checkpoint ()
8776 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8778 uint64_t words_cur
= get_lowest_words_done ();
8780 if (words_cur
!= data
.checkpoint_cur_words
)
8790 uint
set_gpu_accel (uint hash_mode
)
8794 case 0: return GET_ACCEL (0);
8795 case 10: return GET_ACCEL (10);
8796 case 11: return GET_ACCEL (11);
8797 case 12: return GET_ACCEL (12);
8798 case 20: return GET_ACCEL (20);
8799 case 21: return GET_ACCEL (21);
8800 case 22: return GET_ACCEL (22);
8801 case 23: return GET_ACCEL (23);
8802 case 30: return GET_ACCEL (30);
8803 case 40: return GET_ACCEL (40);
8804 case 50: return GET_ACCEL (50);
8805 case 60: return GET_ACCEL (60);
8806 case 100: return GET_ACCEL (100);
8807 case 101: return GET_ACCEL (101);
8808 case 110: return GET_ACCEL (110);
8809 case 111: return GET_ACCEL (111);
8810 case 112: return GET_ACCEL (112);
8811 case 120: return GET_ACCEL (120);
8812 case 121: return GET_ACCEL (121);
8813 case 122: return GET_ACCEL (122);
8814 case 124: return GET_ACCEL (124);
8815 case 130: return GET_ACCEL (130);
8816 case 131: return GET_ACCEL (131);
8817 case 132: return GET_ACCEL (132);
8818 case 133: return GET_ACCEL (133);
8819 case 140: return GET_ACCEL (140);
8820 case 141: return GET_ACCEL (141);
8821 case 150: return GET_ACCEL (150);
8822 case 160: return GET_ACCEL (160);
8823 case 190: return GET_ACCEL (190);
8824 case 200: return GET_ACCEL (200);
8825 case 300: return GET_ACCEL (300);
8826 case 400: return GET_ACCEL (400);
8827 case 500: return GET_ACCEL (500);
8828 case 501: return GET_ACCEL (501);
8829 case 900: return GET_ACCEL (900);
8830 case 910: return GET_ACCEL (910);
8831 case 1000: return GET_ACCEL (1000);
8832 case 1100: return GET_ACCEL (1100);
8833 case 1400: return GET_ACCEL (1400);
8834 case 1410: return GET_ACCEL (1410);
8835 case 1420: return GET_ACCEL (1420);
8836 case 1421: return GET_ACCEL (1421);
8837 case 1430: return GET_ACCEL (1430);
8838 case 1440: return GET_ACCEL (1440);
8839 case 1441: return GET_ACCEL (1441);
8840 case 1450: return GET_ACCEL (1450);
8841 case 1460: return GET_ACCEL (1460);
8842 case 1500: return GET_ACCEL (1500);
8843 case 1600: return GET_ACCEL (1600);
8844 case 1700: return GET_ACCEL (1700);
8845 case 1710: return GET_ACCEL (1710);
8846 case 1711: return GET_ACCEL (1711);
8847 case 1720: return GET_ACCEL (1720);
8848 case 1722: return GET_ACCEL (1722);
8849 case 1730: return GET_ACCEL (1730);
8850 case 1731: return GET_ACCEL (1731);
8851 case 1740: return GET_ACCEL (1740);
8852 case 1750: return GET_ACCEL (1750);
8853 case 1760: return GET_ACCEL (1760);
8854 case 1800: return GET_ACCEL (1800);
8855 case 2100: return GET_ACCEL (2100);
8856 case 2400: return GET_ACCEL (2400);
8857 case 2410: return GET_ACCEL (2410);
8858 case 2500: return GET_ACCEL (2500);
8859 case 2600: return GET_ACCEL (2600);
8860 case 2611: return GET_ACCEL (2611);
8861 case 2612: return GET_ACCEL (2612);
8862 case 2711: return GET_ACCEL (2711);
8863 case 2811: return GET_ACCEL (2811);
8864 case 3000: return GET_ACCEL (3000);
8865 case 3100: return GET_ACCEL (3100);
8866 case 3200: return GET_ACCEL (3200);
8867 case 3710: return GET_ACCEL (3710);
8868 case 3711: return GET_ACCEL (3711);
8869 case 3800: return GET_ACCEL (3800);
8870 case 4300: return GET_ACCEL (4300);
8871 case 4400: return GET_ACCEL (4400);
8872 case 4500: return GET_ACCEL (4500);
8873 case 4700: return GET_ACCEL (4700);
8874 case 4800: return GET_ACCEL (4800);
8875 case 4900: return GET_ACCEL (4900);
8876 case 5000: return GET_ACCEL (5000);
8877 case 5100: return GET_ACCEL (5100);
8878 case 5200: return GET_ACCEL (5200);
8879 case 5300: return GET_ACCEL (5300);
8880 case 5400: return GET_ACCEL (5400);
8881 case 5500: return GET_ACCEL (5500);
8882 case 5600: return GET_ACCEL (5600);
8883 case 5700: return GET_ACCEL (5700);
8884 case 5800: return GET_ACCEL (5800);
8885 case 6000: return GET_ACCEL (6000);
8886 case 6100: return GET_ACCEL (6100);
8887 case 6211: return GET_ACCEL (6211);
8888 case 6212: return GET_ACCEL (6212);
8889 case 6213: return GET_ACCEL (6213);
8890 case 6221: return GET_ACCEL (6221);
8891 case 6222: return GET_ACCEL (6222);
8892 case 6223: return GET_ACCEL (6223);
8893 case 6231: return GET_ACCEL (6231);
8894 case 6232: return GET_ACCEL (6232);
8895 case 6233: return GET_ACCEL (6233);
8896 case 6241: return GET_ACCEL (6241);
8897 case 6242: return GET_ACCEL (6242);
8898 case 6243: return GET_ACCEL (6243);
8899 case 6300: return GET_ACCEL (6300);
8900 case 6400: return GET_ACCEL (6400);
8901 case 6500: return GET_ACCEL (6500);
8902 case 6600: return GET_ACCEL (6600);
8903 case 6700: return GET_ACCEL (6700);
8904 case 6800: return GET_ACCEL (6800);
8905 case 6900: return GET_ACCEL (6900);
8906 case 7100: return GET_ACCEL (7100);
8907 case 7200: return GET_ACCEL (7200);
8908 case 7300: return GET_ACCEL (7300);
8909 case 7400: return GET_ACCEL (7400);
8910 case 7500: return GET_ACCEL (7500);
8911 case 7600: return GET_ACCEL (7600);
8912 case 7700: return GET_ACCEL (7700);
8913 case 7800: return GET_ACCEL (7800);
8914 case 7900: return GET_ACCEL (7900);
8915 case 8000: return GET_ACCEL (8000);
8916 case 8100: return GET_ACCEL (8100);
8917 case 8200: return GET_ACCEL (8200);
8918 case 8300: return GET_ACCEL (8300);
8919 case 8400: return GET_ACCEL (8400);
8920 case 8500: return GET_ACCEL (8500);
8921 case 8600: return GET_ACCEL (8600);
8922 case 8700: return GET_ACCEL (8700);
8923 case 8800: return GET_ACCEL (8800);
8924 case 8900: return GET_ACCEL (8900);
8925 case 9000: return GET_ACCEL (9000);
8926 case 9100: return GET_ACCEL (9100);
8927 case 9200: return GET_ACCEL (9200);
8928 case 9300: return GET_ACCEL (9300);
8929 case 9400: return GET_ACCEL (9400);
8930 case 9500: return GET_ACCEL (9500);
8931 case 9600: return GET_ACCEL (9600);
8932 case 9700: return GET_ACCEL (9700);
8933 case 9710: return GET_ACCEL (9710);
8934 case 9720: return GET_ACCEL (9720);
8935 case 9800: return GET_ACCEL (9800);
8936 case 9810: return GET_ACCEL (9810);
8937 case 9820: return GET_ACCEL (9820);
8938 case 9900: return GET_ACCEL (9900);
8939 case 10000: return GET_ACCEL (10000);
8940 case 10100: return GET_ACCEL (10100);
8941 case 10200: return GET_ACCEL (10200);
8942 case 10300: return GET_ACCEL (10300);
8943 case 10400: return GET_ACCEL (10400);
8944 case 10410: return GET_ACCEL (10410);
8945 case 10420: return GET_ACCEL (10420);
8946 case 10500: return GET_ACCEL (10500);
8947 case 10600: return GET_ACCEL (10600);
8948 case 10700: return GET_ACCEL (10700);
8949 case 10800: return GET_ACCEL (10800);
8950 case 10900: return GET_ACCEL (10900);
8951 case 11000: return GET_ACCEL (11000);
8952 case 11100: return GET_ACCEL (11100);
8953 case 11200: return GET_ACCEL (11200);
8954 case 11300: return GET_ACCEL (11300);
8955 case 11400: return GET_ACCEL (11400);
8956 case 11500: return GET_ACCEL (11500);
8957 case 11600: return GET_ACCEL (11600);
8958 case 11700: return GET_ACCEL (11700);
8959 case 11800: return GET_ACCEL (11800);
8960 case 11900: return GET_ACCEL (11900);
8961 case 12000: return GET_ACCEL (12000);
8962 case 12100: return GET_ACCEL (12100);
8963 case 12200: return GET_ACCEL (12200);
8964 case 12300: return GET_ACCEL (12300);
8965 case 12400: return GET_ACCEL (12400);
8966 case 12500: return GET_ACCEL (12500);
8967 case 12600: return GET_ACCEL (12600);
8968 case 12700: return GET_ACCEL (12700);
8969 case 12800: return GET_ACCEL (12800);
8975 uint
set_gpu_loops (uint hash_mode
)
8979 case 0: return GET_LOOPS (0);
8980 case 10: return GET_LOOPS (10);
8981 case 11: return GET_LOOPS (11);
8982 case 12: return GET_LOOPS (12);
8983 case 20: return GET_LOOPS (20);
8984 case 21: return GET_LOOPS (21);
8985 case 22: return GET_LOOPS (22);
8986 case 23: return GET_LOOPS (23);
8987 case 30: return GET_LOOPS (30);
8988 case 40: return GET_LOOPS (40);
8989 case 50: return GET_LOOPS (50);
8990 case 60: return GET_LOOPS (60);
8991 case 100: return GET_LOOPS (100);
8992 case 101: return GET_LOOPS (101);
8993 case 110: return GET_LOOPS (110);
8994 case 111: return GET_LOOPS (111);
8995 case 112: return GET_LOOPS (112);
8996 case 120: return GET_LOOPS (120);
8997 case 121: return GET_LOOPS (121);
8998 case 122: return GET_LOOPS (122);
8999 case 124: return GET_LOOPS (124);
9000 case 130: return GET_LOOPS (130);
9001 case 131: return GET_LOOPS (131);
9002 case 132: return GET_LOOPS (132);
9003 case 133: return GET_LOOPS (133);
9004 case 140: return GET_LOOPS (140);
9005 case 141: return GET_LOOPS (141);
9006 case 150: return GET_LOOPS (150);
9007 case 160: return GET_LOOPS (160);
9008 case 190: return GET_LOOPS (190);
9009 case 200: return GET_LOOPS (200);
9010 case 300: return GET_LOOPS (300);
9011 case 400: return GET_LOOPS (400);
9012 case 500: return GET_LOOPS (500);
9013 case 501: return GET_LOOPS (501);
9014 case 900: return GET_LOOPS (900);
9015 case 910: return GET_LOOPS (910);
9016 case 1000: return GET_LOOPS (1000);
9017 case 1100: return GET_LOOPS (1100);
9018 case 1400: return GET_LOOPS (1400);
9019 case 1410: return GET_LOOPS (1410);
9020 case 1420: return GET_LOOPS (1420);
9021 case 1421: return GET_LOOPS (1421);
9022 case 1430: return GET_LOOPS (1430);
9023 case 1440: return GET_LOOPS (1440);
9024 case 1441: return GET_LOOPS (1441);
9025 case 1450: return GET_LOOPS (1450);
9026 case 1460: return GET_LOOPS (1460);
9027 case 1500: return GET_LOOPS (1500);
9028 case 1600: return GET_LOOPS (1600);
9029 case 1700: return GET_LOOPS (1700);
9030 case 1710: return GET_LOOPS (1710);
9031 case 1711: return GET_LOOPS (1711);
9032 case 1720: return GET_LOOPS (1720);
9033 case 1722: return GET_LOOPS (1722);
9034 case 1730: return GET_LOOPS (1730);
9035 case 1731: return GET_LOOPS (1731);
9036 case 1740: return GET_LOOPS (1740);
9037 case 1750: return GET_LOOPS (1750);
9038 case 1760: return GET_LOOPS (1760);
9039 case 1800: return GET_LOOPS (1800);
9040 case 2100: return GET_LOOPS (2100);
9041 case 2400: return GET_LOOPS (2400);
9042 case 2410: return GET_LOOPS (2410);
9043 case 2500: return GET_LOOPS (2500);
9044 case 2600: return GET_LOOPS (2600);
9045 case 2611: return GET_LOOPS (2611);
9046 case 2612: return GET_LOOPS (2612);
9047 case 2711: return GET_LOOPS (2711);
9048 case 2811: return GET_LOOPS (2811);
9049 case 3000: return GET_LOOPS (3000);
9050 case 3100: return GET_LOOPS (3100);
9051 case 3200: return GET_LOOPS (3200);
9052 case 3710: return GET_LOOPS (3710);
9053 case 3711: return GET_LOOPS (3711);
9054 case 3800: return GET_LOOPS (3800);
9055 case 4300: return GET_LOOPS (4300);
9056 case 4400: return GET_LOOPS (4400);
9057 case 4500: return GET_LOOPS (4500);
9058 case 4700: return GET_LOOPS (4700);
9059 case 4800: return GET_LOOPS (4800);
9060 case 4900: return GET_LOOPS (4900);
9061 case 5000: return GET_LOOPS (5000);
9062 case 5100: return GET_LOOPS (5100);
9063 case 5200: return GET_LOOPS (5200);
9064 case 5300: return GET_LOOPS (5300);
9065 case 5400: return GET_LOOPS (5400);
9066 case 5500: return GET_LOOPS (5500);
9067 case 5600: return GET_LOOPS (5600);
9068 case 5700: return GET_LOOPS (5700);
9069 case 5800: return GET_LOOPS (5800);
9070 case 6000: return GET_LOOPS (6000);
9071 case 6100: return GET_LOOPS (6100);
9072 case 6211: return GET_LOOPS (6211);
9073 case 6212: return GET_LOOPS (6212);
9074 case 6213: return GET_LOOPS (6213);
9075 case 6221: return GET_LOOPS (6221);
9076 case 6222: return GET_LOOPS (6222);
9077 case 6223: return GET_LOOPS (6223);
9078 case 6231: return GET_LOOPS (6231);
9079 case 6232: return GET_LOOPS (6232);
9080 case 6233: return GET_LOOPS (6233);
9081 case 6241: return GET_LOOPS (6241);
9082 case 6242: return GET_LOOPS (6242);
9083 case 6243: return GET_LOOPS (6243);
9084 case 6300: return GET_LOOPS (6300);
9085 case 6400: return GET_LOOPS (6400);
9086 case 6500: return GET_LOOPS (6500);
9087 case 6600: return GET_LOOPS (6600);
9088 case 6700: return GET_LOOPS (6700);
9089 case 6800: return GET_LOOPS (6800);
9090 case 6900: return GET_LOOPS (6900);
9091 case 7100: return GET_LOOPS (7100);
9092 case 7200: return GET_LOOPS (7200);
9093 case 7300: return GET_LOOPS (7300);
9094 case 7400: return GET_LOOPS (7400);
9095 case 7500: return GET_LOOPS (7500);
9096 case 7600: return GET_LOOPS (7600);
9097 case 7700: return GET_LOOPS (7700);
9098 case 7800: return GET_LOOPS (7800);
9099 case 7900: return GET_LOOPS (7900);
9100 case 8000: return GET_LOOPS (8000);
9101 case 8100: return GET_LOOPS (8100);
9102 case 8200: return GET_LOOPS (8200);
9103 case 8300: return GET_LOOPS (8300);
9104 case 8400: return GET_LOOPS (8400);
9105 case 8500: return GET_LOOPS (8500);
9106 case 8600: return GET_LOOPS (8600);
9107 case 8700: return GET_LOOPS (8700);
9108 case 8800: return GET_LOOPS (8800);
9109 case 8900: return GET_LOOPS (8900);
9110 case 9000: return GET_LOOPS (9000);
9111 case 9100: return GET_LOOPS (9100);
9112 case 9200: return GET_LOOPS (9200);
9113 case 9300: return GET_LOOPS (9300);
9114 case 9400: return GET_LOOPS (9400);
9115 case 9500: return GET_LOOPS (9500);
9116 case 9600: return GET_LOOPS (9600);
9117 case 9700: return GET_LOOPS (9700);
9118 case 9710: return GET_LOOPS (9710);
9119 case 9720: return GET_LOOPS (9720);
9120 case 9800: return GET_LOOPS (9800);
9121 case 9810: return GET_LOOPS (9810);
9122 case 9820: return GET_LOOPS (9820);
9123 case 9900: return GET_LOOPS (9900);
9124 case 10000: return GET_LOOPS (10000);
9125 case 10100: return GET_LOOPS (10100);
9126 case 10200: return GET_LOOPS (10200);
9127 case 10300: return GET_LOOPS (10300);
9128 case 10400: return GET_LOOPS (10400);
9129 case 10410: return GET_LOOPS (10410);
9130 case 10420: return GET_LOOPS (10420);
9131 case 10500: return GET_LOOPS (10500);
9132 case 10600: return GET_LOOPS (10600);
9133 case 10700: return GET_LOOPS (10700);
9134 case 10800: return GET_LOOPS (10800);
9135 case 10900: return GET_LOOPS (10900);
9136 case 11000: return GET_LOOPS (11000);
9137 case 11100: return GET_LOOPS (11100);
9138 case 11200: return GET_LOOPS (11200);
9139 case 11300: return GET_LOOPS (11300);
9140 case 11400: return GET_LOOPS (11400);
9141 case 11500: return GET_LOOPS (11500);
9142 case 11600: return GET_LOOPS (11600);
9143 case 11700: return GET_LOOPS (11700);
9144 case 11800: return GET_LOOPS (11800);
9145 case 11900: return GET_LOOPS (11900);
9146 case 12000: return GET_LOOPS (12000);
9147 case 12100: return GET_LOOPS (12100);
9148 case 12200: return GET_LOOPS (12200);
9149 case 12300: return GET_LOOPS (12300);
9150 case 12400: return GET_LOOPS (12400);
9151 case 12500: return GET_LOOPS (12500);
9152 case 12600: return GET_LOOPS (12600);
9153 case 12700: return GET_LOOPS (12700);
9154 case 12800: return GET_LOOPS (12800);
9164 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9168 if (salt_len
> sizeof(tmp
))
9173 memset (tmp
, 0, sizeof (tmp
));
9174 memcpy (tmp
, in
, salt_len
);
9176 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9178 if ((salt_len
% 2) == 0)
9180 uint new_salt_len
= salt_len
/ 2;
9182 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9184 char p0
= tmp
[j
+ 0];
9185 char p1
= tmp
[j
+ 1];
9187 tmp
[i
] = hex_convert (p1
) << 0;
9188 tmp
[i
] |= hex_convert (p0
) << 4;
9191 salt_len
= new_salt_len
;
9198 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9200 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9203 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9205 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9209 uint
*tmp_uint
= (uint
*) tmp
;
9211 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9212 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9213 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9214 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9215 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9216 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9217 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9218 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9219 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9220 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9222 salt_len
= salt_len
* 2;
9230 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9232 lowercase (tmp
, salt_len
);
9235 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9237 uppercase (tmp
, salt_len
);
9240 uint len
= salt_len
;
9242 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9247 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9252 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9254 uint
*tmp_uint
= (uint
*) tmp
;
9260 for (uint i
= 0; i
< max
; i
++)
9262 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9265 // Important: we may need to increase the length of memcpy since
9266 // we don't want to "loose" some swapped bytes (could happen if
9267 // they do not perfectly fit in the 4-byte blocks)
9268 // Memcpy does always copy the bytes in the BE order, but since
9269 // we swapped them, some important bytes could be in positions
9270 // we normally skip with the original len
9272 if (len
% 4) len
+= 4 - (len
% 4);
9275 memcpy (out
, tmp
, len
);
9280 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9282 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9284 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9286 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9288 salt_t
*salt
= hash_buf
->salt
;
9290 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9292 char *iter_pos
= input_buf
+ 4;
9294 salt
->salt_iter
= 1 << atoi (iter_pos
);
9296 char *salt_pos
= strchr (iter_pos
, '$');
9298 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9304 salt
->salt_len
= salt_len
;
9308 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9310 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9312 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9314 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9316 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9317 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9318 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9319 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9321 char *hash_pos
= salt_pos
+ 22;
9323 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9325 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9327 memcpy (digest
, tmp_buf
, 24);
9329 digest
[0] = byte_swap_32 (digest
[0]);
9330 digest
[1] = byte_swap_32 (digest
[1]);
9331 digest
[2] = byte_swap_32 (digest
[2]);
9332 digest
[3] = byte_swap_32 (digest
[3]);
9333 digest
[4] = byte_swap_32 (digest
[4]);
9334 digest
[5] = byte_swap_32 (digest
[5]);
9336 digest
[5] &= ~0xff; // its just 23 not 24 !
9341 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9343 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9345 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9349 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9351 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9353 memcpy (digest
, tmp_buf
, 32);
9355 digest
[0] = byte_swap_32 (digest
[0]);
9356 digest
[1] = byte_swap_32 (digest
[1]);
9357 digest
[2] = byte_swap_32 (digest
[2]);
9358 digest
[3] = byte_swap_32 (digest
[3]);
9359 digest
[4] = byte_swap_32 (digest
[4]);
9360 digest
[5] = byte_swap_32 (digest
[5]);
9361 digest
[6] = byte_swap_32 (digest
[6]);
9362 digest
[7] = byte_swap_32 (digest
[7]);
9364 digest
[0] -= SHA256M_A
;
9365 digest
[1] -= SHA256M_B
;
9366 digest
[2] -= SHA256M_C
;
9367 digest
[3] -= SHA256M_D
;
9368 digest
[4] -= SHA256M_E
;
9369 digest
[5] -= SHA256M_F
;
9370 digest
[6] -= SHA256M_G
;
9371 digest
[7] -= SHA256M_H
;
9376 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9378 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9380 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9382 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9383 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9385 digest
[0] = byte_swap_32 (digest
[0]);
9386 digest
[1] = byte_swap_32 (digest
[1]);
9390 IP (digest
[0], digest
[1], tt
);
9392 digest
[0] = digest
[0];
9393 digest
[1] = digest
[1];
9400 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9402 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9404 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9406 salt_t
*salt
= hash_buf
->salt
;
9408 char *hash_pos
= input_buf
+ 8;
9410 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9411 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9412 digest
[2] = hex_to_uint (&hash_pos
[16]);
9413 digest
[3] = hex_to_uint (&hash_pos
[24]);
9414 digest
[4] = hex_to_uint (&hash_pos
[32]);
9416 digest
[0] -= SHA1M_A
;
9417 digest
[1] -= SHA1M_B
;
9418 digest
[2] -= SHA1M_C
;
9419 digest
[3] -= SHA1M_D
;
9420 digest
[4] -= SHA1M_E
;
9424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9426 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9428 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9430 salt
->salt_len
= salt_len
;
9435 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9437 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9439 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9441 salt_t
*salt
= hash_buf
->salt
;
9443 char *hash_pos
= input_buf
+ 8;
9445 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9446 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9447 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9448 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9449 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9450 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9451 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9452 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9454 digest
[0] -= SHA512M_A
;
9455 digest
[1] -= SHA512M_B
;
9456 digest
[2] -= SHA512M_C
;
9457 digest
[3] -= SHA512M_D
;
9458 digest
[4] -= SHA512M_E
;
9459 digest
[5] -= SHA512M_F
;
9460 digest
[6] -= SHA512M_G
;
9461 digest
[7] -= SHA512M_H
;
9465 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9467 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9469 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9471 salt
->salt_len
= salt_len
;
9476 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9478 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9480 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9484 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9487 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9489 salt_t
*salt
= hash_buf
->salt
;
9491 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9492 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9493 digest
[2] = hex_to_uint (&input_buf
[16]);
9494 digest
[3] = hex_to_uint (&input_buf
[24]);
9496 digest
[0] = byte_swap_32 (digest
[0]);
9497 digest
[1] = byte_swap_32 (digest
[1]);
9498 digest
[2] = byte_swap_32 (digest
[2]);
9499 digest
[3] = byte_swap_32 (digest
[3]);
9501 digest
[0] -= MD5M_A
;
9502 digest
[1] -= MD5M_B
;
9503 digest
[2] -= MD5M_C
;
9504 digest
[3] -= MD5M_D
;
9506 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9508 uint salt_len
= input_len
- 32 - 1;
9510 char *salt_buf
= input_buf
+ 32 + 1;
9512 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9514 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9516 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9518 salt
->salt_len
= salt_len
;
9523 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9525 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9527 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9531 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9536 char clean_input_buf
[32];
9538 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9539 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9541 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9545 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9551 clean_input_buf
[k
] = input_buf
[i
];
9559 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9561 salt_t
*salt
= hash_buf
->salt
;
9563 char a
, b
, c
, d
, e
, f
;
9565 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9566 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9567 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9568 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9569 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9570 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9572 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9573 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9575 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9576 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9577 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9578 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9579 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9580 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9582 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9583 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9585 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9586 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9587 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9588 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9589 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9590 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9592 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9593 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9595 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9596 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9597 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9598 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9599 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9600 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9602 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9603 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9605 digest
[0] = byte_swap_32 (digest
[0]);
9606 digest
[1] = byte_swap_32 (digest
[1]);
9607 digest
[2] = byte_swap_32 (digest
[2]);
9608 digest
[3] = byte_swap_32 (digest
[3]);
9610 digest
[0] -= MD5M_A
;
9611 digest
[1] -= MD5M_B
;
9612 digest
[2] -= MD5M_C
;
9613 digest
[3] -= MD5M_D
;
9615 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9617 uint salt_len
= input_len
- 30 - 1;
9619 char *salt_buf
= input_buf
+ 30 + 1;
9621 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9623 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9625 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9626 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9628 salt
->salt_len
= salt_len
;
9630 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9632 salt
->salt_len
+= 22;
9637 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9639 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9641 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9645 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9648 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9650 salt_t
*salt
= hash_buf
->salt
;
9652 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9653 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9654 digest
[2] = hex_to_uint (&input_buf
[16]);
9655 digest
[3] = hex_to_uint (&input_buf
[24]);
9656 digest
[4] = hex_to_uint (&input_buf
[32]);
9658 digest
[0] -= SHA1M_A
;
9659 digest
[1] -= SHA1M_B
;
9660 digest
[2] -= SHA1M_C
;
9661 digest
[3] -= SHA1M_D
;
9662 digest
[4] -= SHA1M_E
;
9664 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9666 uint salt_len
= input_len
- 40 - 1;
9668 char *salt_buf
= input_buf
+ 40 + 1;
9670 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9672 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9674 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9676 salt
->salt_len
= salt_len
;
9681 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9683 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9685 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9689 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9692 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9694 char *iter_pos
= input_buf
+ 6;
9696 salt_t
*salt
= hash_buf
->salt
;
9698 salt
->salt_iter
= atoi (iter_pos
) - 1;
9700 char *salt_pos
= strchr (iter_pos
, '#');
9702 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9706 char *digest_pos
= strchr (salt_pos
, '#');
9708 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9712 uint salt_len
= digest_pos
- salt_pos
- 1;
9714 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9716 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9717 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9718 digest
[2] = hex_to_uint (&digest_pos
[16]);
9719 digest
[3] = hex_to_uint (&digest_pos
[24]);
9721 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9723 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9725 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9727 salt
->salt_len
= salt_len
;
9732 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9734 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9736 salt_t
*salt
= hash_buf
->salt
;
9738 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9742 memcpy (&in
, input_buf
, input_len
);
9744 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9746 memcpy (digest
, in
.keymic
, 16);
9749 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9750 The phrase "Pairwise key expansion"
9751 Access Point Address (Referred to as Authenticator Address AA)
9752 Supplicant Address (referred to as Supplicant Address SA)
9753 Access Point Nonce (referred to as Authenticator Anonce)
9754 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9757 uint salt_len
= strlen (in
.essid
);
9759 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9761 salt
->salt_len
= salt_len
;
9763 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9765 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9767 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9769 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9771 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9772 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9776 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9777 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9780 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9782 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9783 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9787 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9788 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9791 for (int i
= 0; i
< 25; i
++)
9793 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9796 wpa
->keyver
= in
.keyver
;
9798 if (wpa
->keyver
> 255)
9800 log_info ("ATTENTION!");
9801 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9802 log_info (" This could be due to a recent aircrack-ng bug.");
9803 log_info (" The key version was automatically reset to a reasonable value.");
9806 wpa
->keyver
&= 0xff;
9809 wpa
->eapol_size
= in
.eapol_size
;
9811 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9813 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9815 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9817 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9819 if (wpa
->keyver
== 1)
9825 digest
[0] = byte_swap_32 (digest
[0]);
9826 digest
[1] = byte_swap_32 (digest
[1]);
9827 digest
[2] = byte_swap_32 (digest
[2]);
9828 digest
[3] = byte_swap_32 (digest
[3]);
9830 for (int i
= 0; i
< 64; i
++)
9832 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9836 salt
->salt_buf
[10] = digest
[1];
9837 salt
->salt_buf
[11] = digest
[2];
9842 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9844 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9846 salt_t
*salt
= hash_buf
->salt
;
9850 log_error ("Password Safe v2 container not specified");
9855 FILE *fp
= fopen (input_buf
, "rb");
9859 log_error ("%s: %s", input_buf
, strerror (errno
));
9868 uint32_t salt
[5]; // unused, but makes better valid check
9869 uint32_t iv
[2]; // unused, but makes better valid check
9875 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9879 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9881 salt
->salt_buf
[0] = buf
.random
[0];
9882 salt
->salt_buf
[1] = buf
.random
[1];
9885 salt
->salt_iter
= 1000;
9887 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9888 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9889 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9890 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9891 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9896 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9898 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9900 salt_t
*salt
= hash_buf
->salt
;
9904 log_error (".psafe3 not specified");
9909 FILE *fp
= fopen (input_buf
, "rb");
9913 log_error ("%s: %s", input_buf
, strerror (errno
));
9920 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9924 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9926 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9928 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9930 salt
->salt_iter
= in
.iterations
+ 1;
9932 salt
->salt_buf
[0] = in
.salt_buf
[0];
9933 salt
->salt_buf
[1] = in
.salt_buf
[1];
9934 salt
->salt_buf
[2] = in
.salt_buf
[2];
9935 salt
->salt_buf
[3] = in
.salt_buf
[3];
9936 salt
->salt_buf
[4] = in
.salt_buf
[4];
9937 salt
->salt_buf
[5] = in
.salt_buf
[5];
9938 salt
->salt_buf
[6] = in
.salt_buf
[6];
9939 salt
->salt_buf
[7] = in
.salt_buf
[7];
9941 salt
->salt_len
= 32;
9943 digest
[0] = in
.hash_buf
[0];
9944 digest
[1] = in
.hash_buf
[1];
9945 digest
[2] = in
.hash_buf
[2];
9946 digest
[3] = in
.hash_buf
[3];
9947 digest
[4] = in
.hash_buf
[4];
9948 digest
[5] = in
.hash_buf
[5];
9949 digest
[6] = in
.hash_buf
[6];
9950 digest
[7] = in
.hash_buf
[7];
9952 digest
[0] = byte_swap_32 (digest
[0]);
9953 digest
[1] = byte_swap_32 (digest
[1]);
9954 digest
[2] = byte_swap_32 (digest
[2]);
9955 digest
[3] = byte_swap_32 (digest
[3]);
9956 digest
[4] = byte_swap_32 (digest
[4]);
9957 digest
[5] = byte_swap_32 (digest
[5]);
9958 digest
[6] = byte_swap_32 (digest
[6]);
9959 digest
[7] = byte_swap_32 (digest
[7]);
9964 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9966 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
9968 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
9970 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9972 salt_t
*salt
= hash_buf
->salt
;
9974 char *iter_pos
= input_buf
+ 3;
9976 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
9978 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
9980 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
9982 salt
->salt_iter
= salt_iter
;
9984 char *salt_pos
= iter_pos
+ 1;
9988 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
9990 salt
->salt_len
= salt_len
;
9992 char *hash_pos
= salt_pos
+ salt_len
;
9994 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
9999 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10001 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10003 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10005 salt_t
*salt
= hash_buf
->salt
;
10007 char *salt_pos
= input_buf
+ 3;
10009 uint iterations_len
= 0;
10011 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10015 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10017 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10018 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10022 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10026 iterations_len
+= 8;
10030 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10033 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10035 char *hash_pos
= strchr (salt_pos
, '$');
10037 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10039 uint salt_len
= hash_pos
- salt_pos
;
10041 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10043 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10045 salt
->salt_len
= salt_len
;
10049 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10051 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10053 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10055 return (PARSER_OK
);
10058 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10060 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10062 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10064 salt_t
*salt
= hash_buf
->salt
;
10066 char *salt_pos
= input_buf
+ 6;
10068 uint iterations_len
= 0;
10070 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10074 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10076 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10077 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10081 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10085 iterations_len
+= 8;
10089 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10092 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10094 char *hash_pos
= strchr (salt_pos
, '$');
10096 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10098 uint salt_len
= hash_pos
- salt_pos
;
10100 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10102 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10104 salt
->salt_len
= salt_len
;
10108 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10110 return (PARSER_OK
);
10113 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10115 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10117 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10119 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10121 salt_t
*salt
= hash_buf
->salt
;
10123 char *salt_pos
= input_buf
+ 14;
10125 char *hash_pos
= strchr (salt_pos
, '*');
10127 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10131 uint salt_len
= hash_pos
- salt_pos
- 1;
10133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10139 salt
->salt_len
= salt_len
;
10141 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10143 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10145 memcpy (digest
, tmp_buf
, 20);
10147 digest
[0] = byte_swap_32 (digest
[0]);
10148 digest
[1] = byte_swap_32 (digest
[1]);
10149 digest
[2] = byte_swap_32 (digest
[2]);
10150 digest
[3] = byte_swap_32 (digest
[3]);
10151 digest
[4] = byte_swap_32 (digest
[4]);
10153 digest
[0] -= SHA1M_A
;
10154 digest
[1] -= SHA1M_B
;
10155 digest
[2] -= SHA1M_C
;
10156 digest
[3] -= SHA1M_D
;
10157 digest
[4] -= SHA1M_E
;
10159 return (PARSER_OK
);
10162 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10164 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10166 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10168 if (c12
& 3) return (PARSER_HASH_VALUE
);
10170 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10172 salt_t
*salt
= hash_buf
->salt
;
10174 // for ascii_digest
10175 salt
->salt_sign
[0] = input_buf
[0];
10176 salt
->salt_sign
[1] = input_buf
[1];
10178 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10179 | itoa64_to_int (input_buf
[1]) << 6;
10181 salt
->salt_len
= 2;
10185 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10187 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10189 memcpy (digest
, tmp_buf
, 8);
10193 IP (digest
[0], digest
[1], tt
);
10198 return (PARSER_OK
);
10201 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10203 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10205 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10207 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10208 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10209 digest
[2] = hex_to_uint (&input_buf
[16]);
10210 digest
[3] = hex_to_uint (&input_buf
[24]);
10212 digest
[0] = byte_swap_32 (digest
[0]);
10213 digest
[1] = byte_swap_32 (digest
[1]);
10214 digest
[2] = byte_swap_32 (digest
[2]);
10215 digest
[3] = byte_swap_32 (digest
[3]);
10217 digest
[0] -= MD4M_A
;
10218 digest
[1] -= MD4M_B
;
10219 digest
[2] -= MD4M_C
;
10220 digest
[3] -= MD4M_D
;
10222 return (PARSER_OK
);
10225 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10227 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10229 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10233 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10236 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10238 salt_t
*salt
= hash_buf
->salt
;
10240 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10241 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10242 digest
[2] = hex_to_uint (&input_buf
[16]);
10243 digest
[3] = hex_to_uint (&input_buf
[24]);
10245 digest
[0] = byte_swap_32 (digest
[0]);
10246 digest
[1] = byte_swap_32 (digest
[1]);
10247 digest
[2] = byte_swap_32 (digest
[2]);
10248 digest
[3] = byte_swap_32 (digest
[3]);
10250 digest
[0] -= MD4M_A
;
10251 digest
[1] -= MD4M_B
;
10252 digest
[2] -= MD4M_C
;
10253 digest
[3] -= MD4M_D
;
10255 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10257 uint salt_len
= input_len
- 32 - 1;
10259 char *salt_buf
= input_buf
+ 32 + 1;
10261 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10263 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10265 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10267 salt
->salt_len
= salt_len
;
10269 return (PARSER_OK
);
10272 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10274 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10276 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10278 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10279 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10280 digest
[2] = hex_to_uint (&input_buf
[16]);
10281 digest
[3] = hex_to_uint (&input_buf
[24]);
10283 digest
[0] = byte_swap_32 (digest
[0]);
10284 digest
[1] = byte_swap_32 (digest
[1]);
10285 digest
[2] = byte_swap_32 (digest
[2]);
10286 digest
[3] = byte_swap_32 (digest
[3]);
10288 digest
[0] -= MD5M_A
;
10289 digest
[1] -= MD5M_B
;
10290 digest
[2] -= MD5M_C
;
10291 digest
[3] -= MD5M_D
;
10293 return (PARSER_OK
);
10296 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10298 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10300 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10302 digest
[0] = hex_to_uint (&input_buf
[0]);
10303 digest
[1] = hex_to_uint (&input_buf
[8]);
10307 digest
[0] = byte_swap_32 (digest
[0]);
10308 digest
[1] = byte_swap_32 (digest
[1]);
10310 return (PARSER_OK
);
10313 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10315 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10317 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10321 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10324 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10326 salt_t
*salt
= hash_buf
->salt
;
10328 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10329 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10330 digest
[2] = hex_to_uint (&input_buf
[16]);
10331 digest
[3] = hex_to_uint (&input_buf
[24]);
10333 digest
[0] = byte_swap_32 (digest
[0]);
10334 digest
[1] = byte_swap_32 (digest
[1]);
10335 digest
[2] = byte_swap_32 (digest
[2]);
10336 digest
[3] = byte_swap_32 (digest
[3]);
10338 digest
[0] -= MD5M_A
;
10339 digest
[1] -= MD5M_B
;
10340 digest
[2] -= MD5M_C
;
10341 digest
[3] -= MD5M_D
;
10343 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10345 uint salt_len
= input_len
- 32 - 1;
10347 char *salt_buf
= input_buf
+ 32 + 1;
10349 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10351 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10353 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10355 salt
->salt_len
= salt_len
;
10357 return (PARSER_OK
);
10360 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10362 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10364 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10366 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10367 | itoa64_to_int (input_buf
[ 1]) << 6
10368 | itoa64_to_int (input_buf
[ 2]) << 12
10369 | itoa64_to_int (input_buf
[ 3]) << 18;
10370 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10371 | itoa64_to_int (input_buf
[ 5]) << 6
10372 | itoa64_to_int (input_buf
[ 6]) << 12
10373 | itoa64_to_int (input_buf
[ 7]) << 18;
10374 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10375 | itoa64_to_int (input_buf
[ 9]) << 6
10376 | itoa64_to_int (input_buf
[10]) << 12
10377 | itoa64_to_int (input_buf
[11]) << 18;
10378 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10379 | itoa64_to_int (input_buf
[13]) << 6
10380 | itoa64_to_int (input_buf
[14]) << 12
10381 | itoa64_to_int (input_buf
[15]) << 18;
10383 digest
[0] -= MD5M_A
;
10384 digest
[1] -= MD5M_B
;
10385 digest
[2] -= MD5M_C
;
10386 digest
[3] -= MD5M_D
;
10388 digest
[0] &= 0x00ffffff;
10389 digest
[1] &= 0x00ffffff;
10390 digest
[2] &= 0x00ffffff;
10391 digest
[3] &= 0x00ffffff;
10393 return (PARSER_OK
);
10396 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10398 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10400 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10404 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10407 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10409 salt_t
*salt
= hash_buf
->salt
;
10411 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10412 | itoa64_to_int (input_buf
[ 1]) << 6
10413 | itoa64_to_int (input_buf
[ 2]) << 12
10414 | itoa64_to_int (input_buf
[ 3]) << 18;
10415 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10416 | itoa64_to_int (input_buf
[ 5]) << 6
10417 | itoa64_to_int (input_buf
[ 6]) << 12
10418 | itoa64_to_int (input_buf
[ 7]) << 18;
10419 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10420 | itoa64_to_int (input_buf
[ 9]) << 6
10421 | itoa64_to_int (input_buf
[10]) << 12
10422 | itoa64_to_int (input_buf
[11]) << 18;
10423 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10424 | itoa64_to_int (input_buf
[13]) << 6
10425 | itoa64_to_int (input_buf
[14]) << 12
10426 | itoa64_to_int (input_buf
[15]) << 18;
10428 digest
[0] -= MD5M_A
;
10429 digest
[1] -= MD5M_B
;
10430 digest
[2] -= MD5M_C
;
10431 digest
[3] -= MD5M_D
;
10433 digest
[0] &= 0x00ffffff;
10434 digest
[1] &= 0x00ffffff;
10435 digest
[2] &= 0x00ffffff;
10436 digest
[3] &= 0x00ffffff;
10438 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10440 uint salt_len
= input_len
- 16 - 1;
10442 char *salt_buf
= input_buf
+ 16 + 1;
10444 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10446 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10448 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10450 salt
->salt_len
= salt_len
;
10452 return (PARSER_OK
);
10455 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10457 key
[0] = (nthash
[0] >> 0);
10458 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10459 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10460 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10461 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10462 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10463 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10464 key
[7] = (nthash
[6] << 1);
10476 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10478 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10480 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10482 salt_t
*salt
= hash_buf
->salt
;
10484 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10490 char *user_pos
= input_buf
;
10492 char *unused_pos
= strchr (user_pos
, ':');
10494 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10496 uint user_len
= unused_pos
- user_pos
;
10498 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10502 char *domain_pos
= strchr (unused_pos
, ':');
10504 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10506 uint unused_len
= domain_pos
- unused_pos
;
10508 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10512 char *srvchall_pos
= strchr (domain_pos
, ':');
10514 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10516 uint domain_len
= srvchall_pos
- domain_pos
;
10518 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10522 char *hash_pos
= strchr (srvchall_pos
, ':');
10524 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10526 uint srvchall_len
= hash_pos
- srvchall_pos
;
10528 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10532 char *clichall_pos
= strchr (hash_pos
, ':');
10534 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10536 uint hash_len
= clichall_pos
- hash_pos
;
10538 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10542 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10544 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10547 * store some data for later use
10550 netntlm
->user_len
= user_len
* 2;
10551 netntlm
->domain_len
= domain_len
* 2;
10552 netntlm
->srvchall_len
= srvchall_len
/ 2;
10553 netntlm
->clichall_len
= clichall_len
/ 2;
10555 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10556 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10559 * handle username and domainname
10562 for (uint i
= 0; i
< user_len
; i
++)
10564 *userdomain_ptr
++ = user_pos
[i
];
10565 *userdomain_ptr
++ = 0;
10568 for (uint i
= 0; i
< domain_len
; i
++)
10570 *userdomain_ptr
++ = domain_pos
[i
];
10571 *userdomain_ptr
++ = 0;
10575 * handle server challenge encoding
10578 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10580 const char p0
= srvchall_pos
[i
+ 0];
10581 const char p1
= srvchall_pos
[i
+ 1];
10583 *chall_ptr
++ = hex_convert (p1
) << 0
10584 | hex_convert (p0
) << 4;
10588 * handle client challenge encoding
10591 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10593 const char p0
= clichall_pos
[i
+ 0];
10594 const char p1
= clichall_pos
[i
+ 1];
10596 *chall_ptr
++ = hex_convert (p1
) << 0
10597 | hex_convert (p0
) << 4;
10604 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10606 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10608 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10610 salt
->salt_len
= salt_len
;
10612 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10613 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10614 digest
[2] = hex_to_uint (&hash_pos
[16]);
10615 digest
[3] = hex_to_uint (&hash_pos
[24]);
10617 digest
[0] = byte_swap_32 (digest
[0]);
10618 digest
[1] = byte_swap_32 (digest
[1]);
10619 digest
[2] = byte_swap_32 (digest
[2]);
10620 digest
[3] = byte_swap_32 (digest
[3]);
10622 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10624 uint digest_tmp
[2];
10626 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10627 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10629 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10630 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10632 /* special case 2: ESS */
10634 if (srvchall_len
== 48)
10636 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10640 w
[ 0] = netntlm
->chall_buf
[6];
10641 w
[ 1] = netntlm
->chall_buf
[7];
10642 w
[ 2] = netntlm
->chall_buf
[0];
10643 w
[ 3] = netntlm
->chall_buf
[1];
10666 salt
->salt_buf
[0] = dgst
[0];
10667 salt
->salt_buf
[1] = dgst
[1];
10671 /* precompute netntlmv1 exploit start */
10673 for (uint i
= 0; i
< 0x10000; i
++)
10675 uint key_md4
[2] = { i
, 0 };
10676 uint key_des
[2] = { 0, 0 };
10678 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10683 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10685 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10687 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10689 if (data3
[0] != digest_tmp
[0]) continue;
10690 if (data3
[1] != digest_tmp
[1]) continue;
10692 salt
->salt_buf
[2] = i
;
10694 salt
->salt_len
= 24;
10699 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10700 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10702 /* precompute netntlmv1 exploit stop */
10706 IP (digest
[0], digest
[1], tt
);
10707 IP (digest
[2], digest
[3], tt
);
10709 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10710 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10711 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10712 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10714 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10716 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10717 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10719 return (PARSER_OK
);
10722 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10724 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10726 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10728 salt_t
*salt
= hash_buf
->salt
;
10730 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10736 char *user_pos
= input_buf
;
10738 char *unused_pos
= strchr (user_pos
, ':');
10740 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10742 uint user_len
= unused_pos
- user_pos
;
10744 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10748 char *domain_pos
= strchr (unused_pos
, ':');
10750 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10752 uint unused_len
= domain_pos
- unused_pos
;
10754 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10758 char *srvchall_pos
= strchr (domain_pos
, ':');
10760 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10762 uint domain_len
= srvchall_pos
- domain_pos
;
10764 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10768 char *hash_pos
= strchr (srvchall_pos
, ':');
10770 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10772 uint srvchall_len
= hash_pos
- srvchall_pos
;
10774 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10778 char *clichall_pos
= strchr (hash_pos
, ':');
10780 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10782 uint hash_len
= clichall_pos
- hash_pos
;
10784 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10788 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10790 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10792 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10795 * store some data for later use
10798 netntlm
->user_len
= user_len
* 2;
10799 netntlm
->domain_len
= domain_len
* 2;
10800 netntlm
->srvchall_len
= srvchall_len
/ 2;
10801 netntlm
->clichall_len
= clichall_len
/ 2;
10803 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10804 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10807 * handle username and domainname
10810 for (uint i
= 0; i
< user_len
; i
++)
10812 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10813 *userdomain_ptr
++ = 0;
10816 for (uint i
= 0; i
< domain_len
; i
++)
10818 *userdomain_ptr
++ = domain_pos
[i
];
10819 *userdomain_ptr
++ = 0;
10822 *userdomain_ptr
++ = 0x80;
10825 * handle server challenge encoding
10828 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10830 const char p0
= srvchall_pos
[i
+ 0];
10831 const char p1
= srvchall_pos
[i
+ 1];
10833 *chall_ptr
++ = hex_convert (p1
) << 0
10834 | hex_convert (p0
) << 4;
10838 * handle client challenge encoding
10841 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10843 const char p0
= clichall_pos
[i
+ 0];
10844 const char p1
= clichall_pos
[i
+ 1];
10846 *chall_ptr
++ = hex_convert (p1
) << 0
10847 | hex_convert (p0
) << 4;
10850 *chall_ptr
++ = 0x80;
10853 * handle hash itself
10856 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10857 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10858 digest
[2] = hex_to_uint (&hash_pos
[16]);
10859 digest
[3] = hex_to_uint (&hash_pos
[24]);
10861 digest
[0] = byte_swap_32 (digest
[0]);
10862 digest
[1] = byte_swap_32 (digest
[1]);
10863 digest
[2] = byte_swap_32 (digest
[2]);
10864 digest
[3] = byte_swap_32 (digest
[3]);
10867 * reuse challange data as salt_buf, its the buffer that is most likely unique
10870 salt
->salt_buf
[0] = 0;
10871 salt
->salt_buf
[1] = 0;
10872 salt
->salt_buf
[2] = 0;
10873 salt
->salt_buf
[3] = 0;
10874 salt
->salt_buf
[4] = 0;
10875 salt
->salt_buf
[5] = 0;
10876 salt
->salt_buf
[6] = 0;
10877 salt
->salt_buf
[7] = 0;
10881 uptr
= (uint
*) netntlm
->userdomain_buf
;
10883 for (uint i
= 0; i
< 16; i
+= 16)
10885 md5_64 (uptr
, salt
->salt_buf
);
10888 uptr
= (uint
*) netntlm
->chall_buf
;
10890 for (uint i
= 0; i
< 256; i
+= 16)
10892 md5_64 (uptr
, salt
->salt_buf
);
10895 salt
->salt_len
= 16;
10897 return (PARSER_OK
);
10900 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10902 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10904 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10908 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10911 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10913 salt_t
*salt
= hash_buf
->salt
;
10915 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10916 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10917 digest
[2] = hex_to_uint (&input_buf
[16]);
10918 digest
[3] = hex_to_uint (&input_buf
[24]);
10920 digest
[0] = byte_swap_32 (digest
[0]);
10921 digest
[1] = byte_swap_32 (digest
[1]);
10922 digest
[2] = byte_swap_32 (digest
[2]);
10923 digest
[3] = byte_swap_32 (digest
[3]);
10925 digest
[0] -= MD5M_A
;
10926 digest
[1] -= MD5M_B
;
10927 digest
[2] -= MD5M_C
;
10928 digest
[3] -= MD5M_D
;
10930 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10932 uint salt_len
= input_len
- 32 - 1;
10934 char *salt_buf
= input_buf
+ 32 + 1;
10936 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10938 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10940 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10942 salt
->salt_len
= salt_len
;
10944 return (PARSER_OK
);
10947 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10949 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10951 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10955 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
10958 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10960 salt_t
*salt
= hash_buf
->salt
;
10962 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10963 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10964 digest
[2] = hex_to_uint (&input_buf
[16]);
10965 digest
[3] = hex_to_uint (&input_buf
[24]);
10967 digest
[0] = byte_swap_32 (digest
[0]);
10968 digest
[1] = byte_swap_32 (digest
[1]);
10969 digest
[2] = byte_swap_32 (digest
[2]);
10970 digest
[3] = byte_swap_32 (digest
[3]);
10972 digest
[0] -= MD5M_A
;
10973 digest
[1] -= MD5M_B
;
10974 digest
[2] -= MD5M_C
;
10975 digest
[3] -= MD5M_D
;
10977 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10979 uint salt_len
= input_len
- 32 - 1;
10981 char *salt_buf
= input_buf
+ 32 + 1;
10983 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10985 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10987 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10989 salt
->salt_len
= salt_len
;
10991 return (PARSER_OK
);
10994 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10996 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
10998 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11000 salt_t
*salt
= hash_buf
->salt
;
11002 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11003 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11004 digest
[2] = hex_to_uint (&input_buf
[16]);
11005 digest
[3] = hex_to_uint (&input_buf
[24]);
11007 digest
[0] = byte_swap_32 (digest
[0]);
11008 digest
[1] = byte_swap_32 (digest
[1]);
11009 digest
[2] = byte_swap_32 (digest
[2]);
11010 digest
[3] = byte_swap_32 (digest
[3]);
11012 digest
[0] -= MD5M_A
;
11013 digest
[1] -= MD5M_B
;
11014 digest
[2] -= MD5M_C
;
11015 digest
[3] -= MD5M_D
;
11018 * This is a virtual salt. While the algorithm is basically not salted
11019 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11020 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11023 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11025 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11029 salt
->salt_len
= salt_len
;
11031 return (PARSER_OK
);
11034 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11036 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11038 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11042 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11045 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11047 salt_t
*salt
= hash_buf
->salt
;
11049 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11050 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11051 digest
[2] = hex_to_uint (&input_buf
[16]);
11052 digest
[3] = hex_to_uint (&input_buf
[24]);
11054 digest
[0] = byte_swap_32 (digest
[0]);
11055 digest
[1] = byte_swap_32 (digest
[1]);
11056 digest
[2] = byte_swap_32 (digest
[2]);
11057 digest
[3] = byte_swap_32 (digest
[3]);
11059 digest
[0] -= MD5M_A
;
11060 digest
[1] -= MD5M_B
;
11061 digest
[2] -= MD5M_C
;
11062 digest
[3] -= MD5M_D
;
11064 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11066 uint salt_len
= input_len
- 32 - 1;
11068 char *salt_buf
= input_buf
+ 32 + 1;
11070 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11072 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11074 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11076 salt
->salt_len
= salt_len
;
11078 return (PARSER_OK
);
11081 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11083 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11085 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11089 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11092 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11094 salt_t
*salt
= hash_buf
->salt
;
11096 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11097 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11098 digest
[2] = hex_to_uint (&input_buf
[16]);
11099 digest
[3] = hex_to_uint (&input_buf
[24]);
11101 digest
[0] = byte_swap_32 (digest
[0]);
11102 digest
[1] = byte_swap_32 (digest
[1]);
11103 digest
[2] = byte_swap_32 (digest
[2]);
11104 digest
[3] = byte_swap_32 (digest
[3]);
11106 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11108 uint salt_len
= input_len
- 32 - 1;
11110 char *salt_buf
= input_buf
+ 32 + 1;
11112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11118 salt
->salt_len
= salt_len
;
11120 return (PARSER_OK
);
11123 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11125 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11127 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11131 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11134 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11136 salt_t
*salt
= hash_buf
->salt
;
11138 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11139 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11140 digest
[2] = hex_to_uint (&input_buf
[16]);
11141 digest
[3] = hex_to_uint (&input_buf
[24]);
11143 digest
[0] = byte_swap_32 (digest
[0]);
11144 digest
[1] = byte_swap_32 (digest
[1]);
11145 digest
[2] = byte_swap_32 (digest
[2]);
11146 digest
[3] = byte_swap_32 (digest
[3]);
11148 digest
[0] -= MD4M_A
;
11149 digest
[1] -= MD4M_B
;
11150 digest
[2] -= MD4M_C
;
11151 digest
[3] -= MD4M_D
;
11153 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11155 uint salt_len
= input_len
- 32 - 1;
11157 char *salt_buf
= input_buf
+ 32 + 1;
11159 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11161 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11163 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11165 salt
->salt_len
= salt_len
;
11167 return (PARSER_OK
);
11170 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11172 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11174 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11178 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11181 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11183 salt_t
*salt
= hash_buf
->salt
;
11185 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11186 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11187 digest
[2] = hex_to_uint (&input_buf
[16]);
11188 digest
[3] = hex_to_uint (&input_buf
[24]);
11190 digest
[0] = byte_swap_32 (digest
[0]);
11191 digest
[1] = byte_swap_32 (digest
[1]);
11192 digest
[2] = byte_swap_32 (digest
[2]);
11193 digest
[3] = byte_swap_32 (digest
[3]);
11195 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11197 uint salt_len
= input_len
- 32 - 1;
11199 char *salt_buf
= input_buf
+ 32 + 1;
11201 uint salt_pc_block
[16];
11203 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11205 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11207 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11211 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11213 salt_pc_block
[14] = salt_len
* 8;
11215 uint salt_pc_digest
[4];
11217 salt_pc_digest
[0] = MAGIC_A
;
11218 salt_pc_digest
[1] = MAGIC_B
;
11219 salt_pc_digest
[2] = MAGIC_C
;
11220 salt_pc_digest
[3] = MAGIC_D
;
11222 md5_64 (salt_pc_block
, salt_pc_digest
);
11224 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11225 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11226 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11227 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11229 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11231 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11233 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11235 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11236 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11237 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11238 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11240 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11242 return (PARSER_OK
);
11245 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11247 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11249 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11251 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11252 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11253 digest
[2] = hex_to_uint (&input_buf
[16]);
11254 digest
[3] = hex_to_uint (&input_buf
[24]);
11255 digest
[4] = hex_to_uint (&input_buf
[32]);
11257 digest
[0] -= SHA1M_A
;
11258 digest
[1] -= SHA1M_B
;
11259 digest
[2] -= SHA1M_C
;
11260 digest
[3] -= SHA1M_D
;
11261 digest
[4] -= SHA1M_E
;
11263 return (PARSER_OK
);
11266 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11268 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11270 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11272 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11273 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11274 digest
[2] = hex_to_uint (&input_buf
[16]);
11275 digest
[3] = hex_to_uint (&input_buf
[24]);
11276 digest
[4] = hex_to_uint (&input_buf
[32]);
11278 return (PARSER_OK
);
11281 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11283 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11285 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11289 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11292 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11294 salt_t
*salt
= hash_buf
->salt
;
11296 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11297 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11298 digest
[2] = hex_to_uint (&input_buf
[16]);
11299 digest
[3] = hex_to_uint (&input_buf
[24]);
11300 digest
[4] = hex_to_uint (&input_buf
[32]);
11302 digest
[0] -= SHA1M_A
;
11303 digest
[1] -= SHA1M_B
;
11304 digest
[2] -= SHA1M_C
;
11305 digest
[3] -= SHA1M_D
;
11306 digest
[4] -= SHA1M_E
;
11308 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11310 uint salt_len
= input_len
- 40 - 1;
11312 char *salt_buf
= input_buf
+ 40 + 1;
11314 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11316 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11318 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11320 salt
->salt_len
= salt_len
;
11322 return (PARSER_OK
);
11325 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11327 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11329 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11331 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11335 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11337 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11339 memcpy (digest
, tmp_buf
, 20);
11341 digest
[0] = byte_swap_32 (digest
[0]);
11342 digest
[1] = byte_swap_32 (digest
[1]);
11343 digest
[2] = byte_swap_32 (digest
[2]);
11344 digest
[3] = byte_swap_32 (digest
[3]);
11345 digest
[4] = byte_swap_32 (digest
[4]);
11347 digest
[0] -= SHA1M_A
;
11348 digest
[1] -= SHA1M_B
;
11349 digest
[2] -= SHA1M_C
;
11350 digest
[3] -= SHA1M_D
;
11351 digest
[4] -= SHA1M_E
;
11353 return (PARSER_OK
);
11356 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11358 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11360 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11362 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11364 salt_t
*salt
= hash_buf
->salt
;
11368 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11370 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11372 memcpy (digest
, tmp_buf
, 20);
11374 salt
->salt_len
= tmp_len
- 20;
11376 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11378 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11380 char *ptr
= (char *) salt
->salt_buf
;
11382 ptr
[salt
->salt_len
] = 0x80;
11385 digest
[0] = byte_swap_32 (digest
[0]);
11386 digest
[1] = byte_swap_32 (digest
[1]);
11387 digest
[2] = byte_swap_32 (digest
[2]);
11388 digest
[3] = byte_swap_32 (digest
[3]);
11389 digest
[4] = byte_swap_32 (digest
[4]);
11391 digest
[0] -= SHA1M_A
;
11392 digest
[1] -= SHA1M_B
;
11393 digest
[2] -= SHA1M_C
;
11394 digest
[3] -= SHA1M_D
;
11395 digest
[4] -= SHA1M_E
;
11397 return (PARSER_OK
);
11400 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11402 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11404 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11406 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11408 salt_t
*salt
= hash_buf
->salt
;
11410 char *salt_buf
= input_buf
+ 6;
11414 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11416 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11418 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11420 salt
->salt_len
= salt_len
;
11422 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11424 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11425 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11426 digest
[2] = hex_to_uint (&hash_pos
[16]);
11427 digest
[3] = hex_to_uint (&hash_pos
[24]);
11428 digest
[4] = hex_to_uint (&hash_pos
[32]);
11430 digest
[0] -= SHA1M_A
;
11431 digest
[1] -= SHA1M_B
;
11432 digest
[2] -= SHA1M_C
;
11433 digest
[3] -= SHA1M_D
;
11434 digest
[4] -= SHA1M_E
;
11436 return (PARSER_OK
);
11439 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11441 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11443 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11445 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11447 salt_t
*salt
= hash_buf
->salt
;
11449 char *salt_buf
= input_buf
+ 6;
11453 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11455 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11457 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11459 salt
->salt_len
= salt_len
;
11461 char *hash_pos
= input_buf
+ 6 + 8;
11463 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11464 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11465 digest
[2] = hex_to_uint (&hash_pos
[16]);
11466 digest
[3] = hex_to_uint (&hash_pos
[24]);
11467 digest
[4] = hex_to_uint (&hash_pos
[32]);
11469 digest
[0] -= SHA1M_A
;
11470 digest
[1] -= SHA1M_B
;
11471 digest
[2] -= SHA1M_C
;
11472 digest
[3] -= SHA1M_D
;
11473 digest
[4] -= SHA1M_E
;
11475 return (PARSER_OK
);
11478 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11480 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11482 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11484 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11486 salt_t
*salt
= hash_buf
->salt
;
11488 char *salt_buf
= input_buf
+ 6;
11492 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11494 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11496 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11498 salt
->salt_len
= salt_len
;
11500 char *hash_pos
= input_buf
+ 6 + 8;
11502 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11503 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11504 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11505 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11506 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11507 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11508 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11509 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11511 digest
[0] -= SHA512M_A
;
11512 digest
[1] -= SHA512M_B
;
11513 digest
[2] -= SHA512M_C
;
11514 digest
[3] -= SHA512M_D
;
11515 digest
[4] -= SHA512M_E
;
11516 digest
[5] -= SHA512M_F
;
11517 digest
[6] -= SHA512M_G
;
11518 digest
[7] -= SHA512M_H
;
11520 return (PARSER_OK
);
11523 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11525 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11527 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11531 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11534 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11536 salt_t
*salt
= hash_buf
->salt
;
11538 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11539 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11543 digest
[0] = byte_swap_32 (digest
[0]);
11544 digest
[1] = byte_swap_32 (digest
[1]);
11546 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11548 uint salt_len
= input_len
- 16 - 1;
11550 char *salt_buf
= input_buf
+ 16 + 1;
11552 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11554 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11556 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11558 salt
->salt_len
= salt_len
;
11560 return (PARSER_OK
);
11563 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11565 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11567 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11569 salt_t
*salt
= hash_buf
->salt
;
11571 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11572 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11573 digest
[2] = hex_to_uint (&input_buf
[16]);
11574 digest
[3] = hex_to_uint (&input_buf
[24]);
11575 digest
[4] = hex_to_uint (&input_buf
[32]);
11577 digest
[0] -= SHA1M_A
;
11578 digest
[1] -= SHA1M_B
;
11579 digest
[2] -= SHA1M_C
;
11580 digest
[3] -= SHA1M_D
;
11581 digest
[4] -= SHA1M_E
;
11583 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11585 uint salt_len
= input_len
- 40 - 1;
11587 char *salt_buf
= input_buf
+ 40 + 1;
11589 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11591 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11593 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11595 salt
->salt_len
= salt_len
;
11597 return (PARSER_OK
);
11600 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11602 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11604 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11606 salt_t
*salt
= hash_buf
->salt
;
11608 char *hash_pos
= input_buf
;
11610 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11611 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11612 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11613 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11614 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11615 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11616 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11617 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11618 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11619 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11620 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11621 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11622 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11623 digest
[13] = hex_to_uint (&hash_pos
[104]);
11624 digest
[14] = hex_to_uint (&hash_pos
[112]);
11625 digest
[15] = hex_to_uint (&hash_pos
[120]);
11627 char *salt_pos
= input_buf
+ 128;
11629 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11630 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11631 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11632 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11634 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11635 salt
->salt_len
= 16;
11637 return (PARSER_OK
);
11640 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11642 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11644 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11646 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11647 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11648 digest
[2] = hex_to_uint (&input_buf
[16]);
11649 digest
[3] = hex_to_uint (&input_buf
[24]);
11650 digest
[4] = hex_to_uint (&input_buf
[32]);
11651 digest
[5] = hex_to_uint (&input_buf
[40]);
11652 digest
[6] = hex_to_uint (&input_buf
[48]);
11653 digest
[7] = hex_to_uint (&input_buf
[56]);
11655 digest
[0] -= SHA256M_A
;
11656 digest
[1] -= SHA256M_B
;
11657 digest
[2] -= SHA256M_C
;
11658 digest
[3] -= SHA256M_D
;
11659 digest
[4] -= SHA256M_E
;
11660 digest
[5] -= SHA256M_F
;
11661 digest
[6] -= SHA256M_G
;
11662 digest
[7] -= SHA256M_H
;
11664 return (PARSER_OK
);
11667 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11669 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11671 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11675 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11678 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11680 salt_t
*salt
= hash_buf
->salt
;
11682 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11683 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11684 digest
[2] = hex_to_uint (&input_buf
[16]);
11685 digest
[3] = hex_to_uint (&input_buf
[24]);
11686 digest
[4] = hex_to_uint (&input_buf
[32]);
11687 digest
[5] = hex_to_uint (&input_buf
[40]);
11688 digest
[6] = hex_to_uint (&input_buf
[48]);
11689 digest
[7] = hex_to_uint (&input_buf
[56]);
11691 digest
[0] -= SHA256M_A
;
11692 digest
[1] -= SHA256M_B
;
11693 digest
[2] -= SHA256M_C
;
11694 digest
[3] -= SHA256M_D
;
11695 digest
[4] -= SHA256M_E
;
11696 digest
[5] -= SHA256M_F
;
11697 digest
[6] -= SHA256M_G
;
11698 digest
[7] -= SHA256M_H
;
11700 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11702 uint salt_len
= input_len
- 64 - 1;
11704 char *salt_buf
= input_buf
+ 64 + 1;
11706 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11708 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11710 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11712 salt
->salt_len
= salt_len
;
11714 return (PARSER_OK
);
11717 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11719 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11721 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11723 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11724 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11725 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11726 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11727 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11728 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11732 digest
[0] -= SHA384M_A
;
11733 digest
[1] -= SHA384M_B
;
11734 digest
[2] -= SHA384M_C
;
11735 digest
[3] -= SHA384M_D
;
11736 digest
[4] -= SHA384M_E
;
11737 digest
[5] -= SHA384M_F
;
11741 return (PARSER_OK
);
11744 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11746 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) 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]);
11756 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11757 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11759 digest
[0] -= SHA512M_A
;
11760 digest
[1] -= SHA512M_B
;
11761 digest
[2] -= SHA512M_C
;
11762 digest
[3] -= SHA512M_D
;
11763 digest
[4] -= SHA512M_E
;
11764 digest
[5] -= SHA512M_F
;
11765 digest
[6] -= SHA512M_G
;
11766 digest
[7] -= SHA512M_H
;
11768 return (PARSER_OK
);
11771 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11773 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11775 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11779 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11782 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11784 salt_t
*salt
= hash_buf
->salt
;
11786 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11787 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11788 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11789 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11790 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11791 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11792 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11793 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11795 digest
[0] -= SHA512M_A
;
11796 digest
[1] -= SHA512M_B
;
11797 digest
[2] -= SHA512M_C
;
11798 digest
[3] -= SHA512M_D
;
11799 digest
[4] -= SHA512M_E
;
11800 digest
[5] -= SHA512M_F
;
11801 digest
[6] -= SHA512M_G
;
11802 digest
[7] -= SHA512M_H
;
11804 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11806 uint salt_len
= input_len
- 128 - 1;
11808 char *salt_buf
= input_buf
+ 128 + 1;
11810 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11812 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11814 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11816 salt
->salt_len
= salt_len
;
11818 return (PARSER_OK
);
11821 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11823 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11825 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11827 salt_t
*salt
= hash_buf
->salt
;
11829 char *salt_pos
= input_buf
+ 3;
11831 uint iterations_len
= 0;
11833 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11837 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11839 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11840 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11844 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11848 iterations_len
+= 8;
11852 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11855 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11857 char *hash_pos
= strchr (salt_pos
, '$');
11859 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11861 uint salt_len
= hash_pos
- salt_pos
;
11863 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11865 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11867 salt
->salt_len
= salt_len
;
11871 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11873 return (PARSER_OK
);
11876 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11878 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11880 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11882 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11884 salt_t
*salt
= hash_buf
->salt
;
11886 uint keccak_mdlen
= input_len
/ 2;
11888 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11890 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11892 digest
[i
] = byte_swap_64 (digest
[i
]);
11895 salt
->keccak_mdlen
= keccak_mdlen
;
11897 return (PARSER_OK
);
11900 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11902 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11904 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11906 salt_t
*salt
= hash_buf
->salt
;
11908 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11911 * Parse that strange long line
11918 in_off
[0] = strtok (input_buf
, ":");
11920 in_len
[0] = strlen (in_off
[0]);
11924 for (i
= 1; i
< 9; i
++)
11926 in_off
[i
] = strtok (NULL
, ":");
11928 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11930 in_len
[i
] = strlen (in_off
[i
]);
11935 ptr
= (char *) ikepsk
->msg_buf
;
11937 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11938 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11939 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11940 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11941 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11942 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11946 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11948 ptr
= (char *) ikepsk
->nr_buf
;
11950 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11951 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11955 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
11958 * Store to database
11963 digest
[0] = hex_to_uint (&ptr
[ 0]);
11964 digest
[1] = hex_to_uint (&ptr
[ 8]);
11965 digest
[2] = hex_to_uint (&ptr
[16]);
11966 digest
[3] = hex_to_uint (&ptr
[24]);
11968 digest
[0] = byte_swap_32 (digest
[0]);
11969 digest
[1] = byte_swap_32 (digest
[1]);
11970 digest
[2] = byte_swap_32 (digest
[2]);
11971 digest
[3] = byte_swap_32 (digest
[3]);
11973 salt
->salt_len
= 32;
11975 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
11976 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
11977 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
11978 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
11979 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
11980 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
11981 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
11982 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
11984 return (PARSER_OK
);
11987 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11989 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
11991 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11993 salt_t
*salt
= hash_buf
->salt
;
11995 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11998 * Parse that strange long line
12005 in_off
[0] = strtok (input_buf
, ":");
12007 in_len
[0] = strlen (in_off
[0]);
12011 for (i
= 1; i
< 9; i
++)
12013 in_off
[i
] = strtok (NULL
, ":");
12015 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12017 in_len
[i
] = strlen (in_off
[i
]);
12022 ptr
= (char *) ikepsk
->msg_buf
;
12024 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12025 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12026 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12027 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12028 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12029 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12033 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12035 ptr
= (char *) ikepsk
->nr_buf
;
12037 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12038 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12042 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12045 * Store to database
12050 digest
[0] = hex_to_uint (&ptr
[ 0]);
12051 digest
[1] = hex_to_uint (&ptr
[ 8]);
12052 digest
[2] = hex_to_uint (&ptr
[16]);
12053 digest
[3] = hex_to_uint (&ptr
[24]);
12054 digest
[4] = hex_to_uint (&ptr
[32]);
12056 salt
->salt_len
= 32;
12058 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12059 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12060 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12061 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12062 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12063 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12064 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12065 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12067 return (PARSER_OK
);
12070 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12072 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12074 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12076 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12077 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12078 digest
[2] = hex_to_uint (&input_buf
[16]);
12079 digest
[3] = hex_to_uint (&input_buf
[24]);
12080 digest
[4] = hex_to_uint (&input_buf
[32]);
12082 digest
[0] = byte_swap_32 (digest
[0]);
12083 digest
[1] = byte_swap_32 (digest
[1]);
12084 digest
[2] = byte_swap_32 (digest
[2]);
12085 digest
[3] = byte_swap_32 (digest
[3]);
12086 digest
[4] = byte_swap_32 (digest
[4]);
12088 return (PARSER_OK
);
12091 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12093 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12095 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12097 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12098 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12099 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12100 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12101 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12102 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12103 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12104 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12105 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12106 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12107 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12108 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12109 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12110 digest
[13] = hex_to_uint (&input_buf
[104]);
12111 digest
[14] = hex_to_uint (&input_buf
[112]);
12112 digest
[15] = hex_to_uint (&input_buf
[120]);
12114 return (PARSER_OK
);
12117 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12119 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12121 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12123 salt_t
*salt
= hash_buf
->salt
;
12125 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12126 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12127 digest
[2] = hex_to_uint (&input_buf
[16]);
12128 digest
[3] = hex_to_uint (&input_buf
[24]);
12129 digest
[4] = hex_to_uint (&input_buf
[32]);
12131 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12133 uint salt_len
= input_len
- 40 - 1;
12135 char *salt_buf
= input_buf
+ 40 + 1;
12137 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12139 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12141 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12143 salt
->salt_len
= salt_len
;
12145 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12147 return (PARSER_OK
);
12150 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12152 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12154 salt_t
*salt
= hash_buf
->salt
;
12156 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12158 if (input_len
== 0)
12160 log_error ("TrueCrypt container not specified");
12165 FILE *fp
= fopen (input_buf
, "rb");
12169 log_error ("%s: %s", input_buf
, strerror (errno
));
12176 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12180 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12182 memcpy (tc
->salt_buf
, buf
, 64);
12184 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12186 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12188 salt
->salt_len
= 4;
12190 salt
->salt_iter
= 1000 - 1;
12192 digest
[0] = tc
->data_buf
[0];
12194 return (PARSER_OK
);
12197 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12199 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12201 salt_t
*salt
= hash_buf
->salt
;
12203 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12205 if (input_len
== 0)
12207 log_error ("TrueCrypt container not specified");
12212 FILE *fp
= fopen (input_buf
, "rb");
12216 log_error ("%s: %s", input_buf
, strerror (errno
));
12223 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12227 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12229 memcpy (tc
->salt_buf
, buf
, 64);
12231 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12233 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12235 salt
->salt_len
= 4;
12237 salt
->salt_iter
= 2000 - 1;
12239 digest
[0] = tc
->data_buf
[0];
12241 return (PARSER_OK
);
12244 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12246 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12248 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12250 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12252 salt_t
*salt
= hash_buf
->salt
;
12254 char *salt_pos
= input_buf
+ 6;
12256 char *hash_pos
= strchr (salt_pos
, '$');
12258 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12260 uint salt_len
= hash_pos
- salt_pos
;
12262 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12264 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12266 salt
->salt_len
= salt_len
;
12268 salt
->salt_iter
= 1000;
12272 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12274 return (PARSER_OK
);
12277 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12279 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12281 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12283 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12285 salt_t
*salt
= hash_buf
->salt
;
12287 char *iter_pos
= input_buf
+ 7;
12289 char *salt_pos
= strchr (iter_pos
, '$');
12291 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12295 char *hash_pos
= strchr (salt_pos
, '$');
12297 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12299 uint salt_len
= hash_pos
- salt_pos
;
12301 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12303 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12305 salt
->salt_len
= salt_len
;
12307 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12309 salt
->salt_sign
[0] = atoi (salt_iter
);
12311 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12315 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12317 digest
[0] = byte_swap_32 (digest
[0]);
12318 digest
[1] = byte_swap_32 (digest
[1]);
12319 digest
[2] = byte_swap_32 (digest
[2]);
12320 digest
[3] = byte_swap_32 (digest
[3]);
12321 digest
[4] = byte_swap_32 (digest
[4]);
12323 return (PARSER_OK
);
12326 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12328 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12330 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12332 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12334 salt_t
*salt
= hash_buf
->salt
;
12336 char *iter_pos
= input_buf
+ 9;
12338 char *salt_pos
= strchr (iter_pos
, '$');
12340 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12344 char *hash_pos
= strchr (salt_pos
, '$');
12346 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12348 uint salt_len
= hash_pos
- salt_pos
;
12350 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12352 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12354 salt
->salt_len
= salt_len
;
12356 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12358 salt
->salt_sign
[0] = atoi (salt_iter
);
12360 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12364 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12366 digest
[0] = byte_swap_32 (digest
[0]);
12367 digest
[1] = byte_swap_32 (digest
[1]);
12368 digest
[2] = byte_swap_32 (digest
[2]);
12369 digest
[3] = byte_swap_32 (digest
[3]);
12370 digest
[4] = byte_swap_32 (digest
[4]);
12371 digest
[5] = byte_swap_32 (digest
[5]);
12372 digest
[6] = byte_swap_32 (digest
[6]);
12373 digest
[7] = byte_swap_32 (digest
[7]);
12375 return (PARSER_OK
);
12378 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12380 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12382 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12384 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12386 salt_t
*salt
= hash_buf
->salt
;
12388 char *iter_pos
= input_buf
+ 9;
12390 char *salt_pos
= strchr (iter_pos
, '$');
12392 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12396 char *hash_pos
= strchr (salt_pos
, '$');
12398 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12400 uint salt_len
= hash_pos
- salt_pos
;
12402 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12404 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12406 salt
->salt_len
= salt_len
;
12408 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12410 salt
->salt_sign
[0] = atoi (salt_iter
);
12412 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12416 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12418 digest
[0] = byte_swap_64 (digest
[0]);
12419 digest
[1] = byte_swap_64 (digest
[1]);
12420 digest
[2] = byte_swap_64 (digest
[2]);
12421 digest
[3] = byte_swap_64 (digest
[3]);
12422 digest
[4] = byte_swap_64 (digest
[4]);
12423 digest
[5] = byte_swap_64 (digest
[5]);
12424 digest
[6] = byte_swap_64 (digest
[6]);
12425 digest
[7] = byte_swap_64 (digest
[7]);
12427 return (PARSER_OK
);
12430 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12432 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12434 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12436 salt_t
*salt
= hash_buf
->salt
;
12438 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12444 char *iterations_pos
= input_buf
;
12446 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12448 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12450 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12452 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12456 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12458 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12460 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12462 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12464 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12466 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12471 * pbkdf2 iterations
12474 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12477 * handle salt encoding
12480 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12482 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12484 const char p0
= saltbuf_pos
[i
+ 0];
12485 const char p1
= saltbuf_pos
[i
+ 1];
12487 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12488 | hex_convert (p0
) << 4;
12491 salt
->salt_len
= saltbuf_len
/ 2;
12494 * handle cipher encoding
12497 uint
*tmp
= (uint
*) mymalloc (32);
12499 char *cipherbuf_ptr
= (char *) tmp
;
12501 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12503 const char p0
= cipherbuf_pos
[i
+ 0];
12504 const char p1
= cipherbuf_pos
[i
+ 1];
12506 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12507 | hex_convert (p0
) << 4;
12510 // iv is stored at salt_buf 4 (length 16)
12511 // data is stored at salt_buf 8 (length 16)
12513 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12514 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12515 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12516 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12518 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12519 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12520 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12521 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12525 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12527 const char p0
= cipherbuf_pos
[j
+ 0];
12528 const char p1
= cipherbuf_pos
[j
+ 1];
12530 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12531 | hex_convert (p0
) << 4;
12538 digest
[0] = 0x10101010;
12539 digest
[1] = 0x10101010;
12540 digest
[2] = 0x10101010;
12541 digest
[3] = 0x10101010;
12543 return (PARSER_OK
);
12546 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12548 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12550 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12552 salt_t
*salt
= hash_buf
->salt
;
12554 char *hashbuf_pos
= input_buf
;
12556 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12558 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12560 uint hash_len
= iterations_pos
- hashbuf_pos
;
12562 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12566 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12568 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12570 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12574 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12576 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12578 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12580 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12582 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12584 salt
->salt_len
= salt_len
;
12586 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12588 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12589 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12590 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12591 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12593 return (PARSER_OK
);
12596 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12598 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12600 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12602 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12603 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12604 digest
[2] = hex_to_uint (&input_buf
[16]);
12605 digest
[3] = hex_to_uint (&input_buf
[24]);
12606 digest
[4] = hex_to_uint (&input_buf
[32]);
12607 digest
[5] = hex_to_uint (&input_buf
[40]);
12608 digest
[6] = hex_to_uint (&input_buf
[48]);
12609 digest
[7] = hex_to_uint (&input_buf
[56]);
12611 digest
[0] = byte_swap_32 (digest
[0]);
12612 digest
[1] = byte_swap_32 (digest
[1]);
12613 digest
[2] = byte_swap_32 (digest
[2]);
12614 digest
[3] = byte_swap_32 (digest
[3]);
12615 digest
[4] = byte_swap_32 (digest
[4]);
12616 digest
[5] = byte_swap_32 (digest
[5]);
12617 digest
[6] = byte_swap_32 (digest
[6]);
12618 digest
[7] = byte_swap_32 (digest
[7]);
12620 return (PARSER_OK
);
12623 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12625 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12627 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12629 salt_t
*salt
= hash_buf
->salt
;
12631 char *salt_pos
= input_buf
+ 3;
12633 uint iterations_len
= 0;
12635 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12639 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12641 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12642 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12646 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12650 iterations_len
+= 8;
12654 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12657 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12659 char *hash_pos
= strchr (salt_pos
, '$');
12661 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12663 uint salt_len
= hash_pos
- salt_pos
;
12665 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12667 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12669 salt
->salt_len
= salt_len
;
12673 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12675 return (PARSER_OK
);
12678 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12680 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12682 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12684 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12686 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12688 salt_t
*salt
= hash_buf
->salt
;
12690 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12692 char *iter_pos
= input_buf
+ 4;
12694 char *salt_pos
= strchr (iter_pos
, '$');
12696 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12700 char *hash_pos
= strchr (salt_pos
, '$');
12702 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12704 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12708 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12709 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12710 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12711 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12712 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12713 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12714 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12715 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12717 uint salt_len
= hash_pos
- salt_pos
- 1;
12719 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12721 salt
->salt_len
= salt_len
/ 2;
12723 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12724 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12725 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12726 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12727 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12728 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12729 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12730 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12732 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12733 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12734 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12735 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12736 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12737 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12738 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12739 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12740 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12741 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12743 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12745 salt
->salt_iter
= atoi (iter_pos
) - 1;
12747 return (PARSER_OK
);
12750 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12752 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12754 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12756 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12758 salt_t
*salt
= hash_buf
->salt
;
12760 char *salt_pos
= input_buf
+ 14;
12762 char *hash_pos
= strchr (salt_pos
, '*');
12764 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12768 uint salt_len
= hash_pos
- salt_pos
- 1;
12770 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12772 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12774 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12776 salt
->salt_len
= salt_len
;
12778 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12780 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12782 memcpy (digest
, tmp_buf
, 32);
12784 digest
[0] = byte_swap_32 (digest
[0]);
12785 digest
[1] = byte_swap_32 (digest
[1]);
12786 digest
[2] = byte_swap_32 (digest
[2]);
12787 digest
[3] = byte_swap_32 (digest
[3]);
12788 digest
[4] = byte_swap_32 (digest
[4]);
12789 digest
[5] = byte_swap_32 (digest
[5]);
12790 digest
[6] = byte_swap_32 (digest
[6]);
12791 digest
[7] = byte_swap_32 (digest
[7]);
12793 digest
[0] -= SHA256M_A
;
12794 digest
[1] -= SHA256M_B
;
12795 digest
[2] -= SHA256M_C
;
12796 digest
[3] -= SHA256M_D
;
12797 digest
[4] -= SHA256M_E
;
12798 digest
[5] -= SHA256M_F
;
12799 digest
[6] -= SHA256M_G
;
12800 digest
[7] -= SHA256M_H
;
12802 return (PARSER_OK
);
12805 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12807 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12809 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12811 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12813 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12815 salt_t
*salt
= hash_buf
->salt
;
12817 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12819 char *iter_pos
= input_buf
+ 19;
12821 char *salt_pos
= strchr (iter_pos
, '.');
12823 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12827 char *hash_pos
= strchr (salt_pos
, '.');
12829 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12831 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12835 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12836 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12837 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12838 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12839 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12840 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12841 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12842 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12844 uint salt_len
= hash_pos
- salt_pos
- 1;
12848 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12852 for (i
= 0; i
< salt_len
; i
++)
12854 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12857 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12858 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12860 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12862 salt
->salt_len
= salt_len
;
12864 salt
->salt_iter
= atoi (iter_pos
) - 1;
12866 return (PARSER_OK
);
12869 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12871 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12873 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12875 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12877 salt_t
*salt
= hash_buf
->salt
;
12881 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12883 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12885 memcpy (digest
, tmp_buf
, 64);
12887 digest
[0] = byte_swap_64 (digest
[0]);
12888 digest
[1] = byte_swap_64 (digest
[1]);
12889 digest
[2] = byte_swap_64 (digest
[2]);
12890 digest
[3] = byte_swap_64 (digest
[3]);
12891 digest
[4] = byte_swap_64 (digest
[4]);
12892 digest
[5] = byte_swap_64 (digest
[5]);
12893 digest
[6] = byte_swap_64 (digest
[6]);
12894 digest
[7] = byte_swap_64 (digest
[7]);
12896 digest
[0] -= SHA512M_A
;
12897 digest
[1] -= SHA512M_B
;
12898 digest
[2] -= SHA512M_C
;
12899 digest
[3] -= SHA512M_D
;
12900 digest
[4] -= SHA512M_E
;
12901 digest
[5] -= SHA512M_F
;
12902 digest
[6] -= SHA512M_G
;
12903 digest
[7] -= SHA512M_H
;
12905 salt
->salt_len
= tmp_len
- 64;
12907 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12909 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12911 char *ptr
= (char *) salt
->salt_buf
;
12913 ptr
[salt
->salt_len
] = 0x80;
12916 return (PARSER_OK
);
12919 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12921 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12923 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12927 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12930 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12932 salt_t
*salt
= hash_buf
->salt
;
12934 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12935 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12936 digest
[2] = hex_to_uint (&input_buf
[16]);
12937 digest
[3] = hex_to_uint (&input_buf
[24]);
12939 digest
[0] = byte_swap_32 (digest
[0]);
12940 digest
[1] = byte_swap_32 (digest
[1]);
12941 digest
[2] = byte_swap_32 (digest
[2]);
12942 digest
[3] = byte_swap_32 (digest
[3]);
12944 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12946 uint salt_len
= input_len
- 32 - 1;
12948 char *salt_buf
= input_buf
+ 32 + 1;
12950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12956 salt
->salt_len
= salt_len
;
12958 return (PARSER_OK
);
12961 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12963 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12965 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
12969 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
12972 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12974 salt_t
*salt
= hash_buf
->salt
;
12976 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12977 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12978 digest
[2] = hex_to_uint (&input_buf
[16]);
12979 digest
[3] = hex_to_uint (&input_buf
[24]);
12980 digest
[4] = hex_to_uint (&input_buf
[32]);
12982 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12984 uint salt_len
= input_len
- 40 - 1;
12986 char *salt_buf
= input_buf
+ 40 + 1;
12988 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12990 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12992 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12994 salt
->salt_len
= salt_len
;
12996 return (PARSER_OK
);
12999 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13001 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13003 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13007 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13010 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13012 salt_t
*salt
= hash_buf
->salt
;
13014 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13015 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13016 digest
[2] = hex_to_uint (&input_buf
[16]);
13017 digest
[3] = hex_to_uint (&input_buf
[24]);
13018 digest
[4] = hex_to_uint (&input_buf
[32]);
13019 digest
[5] = hex_to_uint (&input_buf
[40]);
13020 digest
[6] = hex_to_uint (&input_buf
[48]);
13021 digest
[7] = hex_to_uint (&input_buf
[56]);
13023 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13025 uint salt_len
= input_len
- 64 - 1;
13027 char *salt_buf
= input_buf
+ 64 + 1;
13029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13031 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13033 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13035 salt
->salt_len
= salt_len
;
13037 return (PARSER_OK
);
13040 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13042 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13044 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13048 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13051 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13053 salt_t
*salt
= hash_buf
->salt
;
13055 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13056 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13057 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13058 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13059 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13060 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13061 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13062 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13064 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13066 uint salt_len
= input_len
- 128 - 1;
13068 char *salt_buf
= input_buf
+ 128 + 1;
13070 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13072 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13074 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13076 salt
->salt_len
= salt_len
;
13078 return (PARSER_OK
);
13081 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13083 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13085 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13087 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13089 salt_t
*salt
= hash_buf
->salt
;
13091 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13097 char *user_pos
= input_buf
+ 10 + 1;
13099 char *realm_pos
= strchr (user_pos
, '$');
13101 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13103 uint user_len
= realm_pos
- user_pos
;
13105 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13109 char *salt_pos
= strchr (realm_pos
, '$');
13111 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13113 uint realm_len
= salt_pos
- realm_pos
;
13115 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13119 char *data_pos
= strchr (salt_pos
, '$');
13121 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13123 uint salt_len
= data_pos
- salt_pos
;
13125 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13129 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13131 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13137 memcpy (krb5pa
->user
, user_pos
, user_len
);
13138 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13139 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13141 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13143 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13145 const char p0
= data_pos
[i
+ 0];
13146 const char p1
= data_pos
[i
+ 1];
13148 *timestamp_ptr
++ = hex_convert (p1
) << 0
13149 | hex_convert (p0
) << 4;
13152 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13154 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13156 const char p0
= data_pos
[i
+ 0];
13157 const char p1
= data_pos
[i
+ 1];
13159 *checksum_ptr
++ = hex_convert (p1
) << 0
13160 | hex_convert (p0
) << 4;
13164 * copy some data to generic buffers to make sorting happy
13167 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13168 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13169 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13170 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13171 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13172 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13173 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13174 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13175 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13177 salt
->salt_len
= 36;
13179 digest
[0] = krb5pa
->checksum
[0];
13180 digest
[1] = krb5pa
->checksum
[1];
13181 digest
[2] = krb5pa
->checksum
[2];
13182 digest
[3] = krb5pa
->checksum
[3];
13184 return (PARSER_OK
);
13187 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13189 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13191 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13193 salt_t
*salt
= hash_buf
->salt
;
13199 char *salt_pos
= input_buf
;
13201 char *hash_pos
= strchr (salt_pos
, '$');
13203 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13205 uint salt_len
= hash_pos
- salt_pos
;
13207 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13211 uint hash_len
= input_len
- 1 - salt_len
;
13213 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13221 for (uint i
= 0; i
< salt_len
; i
++)
13223 if (salt_pos
[i
] == ' ') continue;
13228 // SAP user names cannot be longer than 12 characters
13229 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13231 // SAP user name cannot start with ! or ?
13232 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13238 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13240 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13242 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13244 salt
->salt_len
= salt_len
;
13246 digest
[0] = hex_to_uint (&hash_pos
[0]);
13247 digest
[1] = hex_to_uint (&hash_pos
[8]);
13251 digest
[0] = byte_swap_32 (digest
[0]);
13252 digest
[1] = byte_swap_32 (digest
[1]);
13254 return (PARSER_OK
);
13257 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13259 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13261 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13263 salt_t
*salt
= hash_buf
->salt
;
13269 char *salt_pos
= input_buf
;
13271 char *hash_pos
= strchr (salt_pos
, '$');
13273 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13275 uint salt_len
= hash_pos
- salt_pos
;
13277 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13281 uint hash_len
= input_len
- 1 - salt_len
;
13283 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13291 for (uint i
= 0; i
< salt_len
; i
++)
13293 if (salt_pos
[i
] == ' ') continue;
13298 // SAP user names cannot be longer than 12 characters
13299 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13301 // SAP user name cannot start with ! or ?
13302 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13308 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13310 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13312 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13314 salt
->salt_len
= salt_len
;
13316 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13317 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13318 digest
[2] = hex_to_uint (&hash_pos
[16]);
13319 digest
[3] = hex_to_uint (&hash_pos
[24]);
13320 digest
[4] = hex_to_uint (&hash_pos
[32]);
13322 return (PARSER_OK
);
13325 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13327 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13329 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13331 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13333 salt_t
*salt
= hash_buf
->salt
;
13335 char *iter_pos
= input_buf
+ 3;
13337 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13339 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13341 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13343 salt
->salt_iter
= salt_iter
;
13345 char *salt_pos
= iter_pos
+ 1;
13349 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13351 salt
->salt_len
= salt_len
;
13353 char *hash_pos
= salt_pos
+ salt_len
;
13355 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13359 char *tmp
= (char *) salt
->salt_buf_pc
;
13361 tmp
[0] = hash_pos
[42];
13365 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13366 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13367 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13368 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13374 return (PARSER_OK
);
13377 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13379 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13381 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13383 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13385 salt_t
*salt
= hash_buf
->salt
;
13387 char *salt_buf
= input_buf
+ 6;
13389 uint salt_len
= 16;
13391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13393 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13395 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13397 salt
->salt_len
= salt_len
;
13399 char *hash_pos
= input_buf
+ 6 + 16;
13401 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13402 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13403 digest
[2] = hex_to_uint (&hash_pos
[16]);
13404 digest
[3] = hex_to_uint (&hash_pos
[24]);
13405 digest
[4] = hex_to_uint (&hash_pos
[32]);
13406 digest
[5] = hex_to_uint (&hash_pos
[40]);
13407 digest
[6] = hex_to_uint (&hash_pos
[48]);
13408 digest
[7] = hex_to_uint (&hash_pos
[56]);
13410 return (PARSER_OK
);
13413 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13415 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13417 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13419 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13420 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13424 return (PARSER_OK
);
13427 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13429 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13431 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13433 salt_t
*salt
= hash_buf
->salt
;
13435 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13437 char *saltbuf_pos
= input_buf
;
13439 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13441 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13443 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13445 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13446 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13448 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13452 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13454 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13456 char *salt_ptr
= (char *) saltbuf_pos
;
13457 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13462 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13464 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13467 rakp_ptr
[j
] = 0x80;
13469 rakp
->salt_len
= j
;
13471 for (i
= 0; i
< 64; i
++)
13473 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13476 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13477 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13478 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13479 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13480 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13481 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13482 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13483 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13485 salt
->salt_len
= 32; // muss min. 32 haben
13487 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13488 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13489 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13490 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13491 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13493 return (PARSER_OK
);
13496 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13498 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13500 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13502 salt_t
*salt
= hash_buf
->salt
;
13504 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13506 char *salt_pos
= input_buf
+ 1;
13508 memcpy (salt
->salt_buf
, salt_pos
, 8);
13510 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13511 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13513 salt
->salt_len
= 8;
13515 char *hash_pos
= salt_pos
+ 8;
13517 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13518 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13519 digest
[2] = hex_to_uint (&hash_pos
[16]);
13520 digest
[3] = hex_to_uint (&hash_pos
[24]);
13521 digest
[4] = hex_to_uint (&hash_pos
[32]);
13523 digest
[0] -= SHA1M_A
;
13524 digest
[1] -= SHA1M_B
;
13525 digest
[2] -= SHA1M_C
;
13526 digest
[3] -= SHA1M_D
;
13527 digest
[4] -= SHA1M_E
;
13529 return (PARSER_OK
);
13532 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13534 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13536 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13538 salt_t
*salt
= hash_buf
->salt
;
13540 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13541 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13542 digest
[2] = hex_to_uint (&input_buf
[16]);
13543 digest
[3] = hex_to_uint (&input_buf
[24]);
13545 digest
[0] = byte_swap_32 (digest
[0]);
13546 digest
[1] = byte_swap_32 (digest
[1]);
13547 digest
[2] = byte_swap_32 (digest
[2]);
13548 digest
[3] = byte_swap_32 (digest
[3]);
13550 digest
[0] -= MD5M_A
;
13551 digest
[1] -= MD5M_B
;
13552 digest
[2] -= MD5M_C
;
13553 digest
[3] -= MD5M_D
;
13555 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13557 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13559 uint32_t *salt_buf
= salt
->salt_buf
;
13561 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13562 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13563 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13564 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13566 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13567 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13568 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13569 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13571 salt
->salt_len
= 16 + 1;
13573 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13575 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13577 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13579 return (PARSER_OK
);
13582 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13584 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13586 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13588 salt_t
*salt
= hash_buf
->salt
;
13590 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13596 char *hashbuf_pos
= input_buf
;
13598 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13600 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13602 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13604 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13608 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13610 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13612 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13614 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13618 char *databuf_pos
= strchr (iteration_pos
, ':');
13620 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13622 const uint iteration_len
= databuf_pos
- iteration_pos
;
13624 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13625 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13627 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13629 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13630 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13636 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13637 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13638 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13639 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13640 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13641 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13642 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13643 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13647 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13649 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13651 const char p0
= saltbuf_pos
[i
+ 0];
13652 const char p1
= saltbuf_pos
[i
+ 1];
13654 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13655 | hex_convert (p0
) << 4;
13658 salt
->salt_buf
[4] = 0x01000000;
13659 salt
->salt_buf
[5] = 0x80;
13661 salt
->salt_len
= saltbuf_len
/ 2;
13665 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13669 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13671 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13673 const char p0
= databuf_pos
[i
+ 0];
13674 const char p1
= databuf_pos
[i
+ 1];
13676 *databuf_ptr
++ = hex_convert (p1
) << 0
13677 | hex_convert (p0
) << 4;
13680 *databuf_ptr
++ = 0x80;
13682 for (uint i
= 0; i
< 512; i
++)
13684 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13687 cloudkey
->data_len
= databuf_len
/ 2;
13689 return (PARSER_OK
);
13692 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13694 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13696 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13698 salt_t
*salt
= hash_buf
->salt
;
13704 char *hashbuf_pos
= input_buf
;
13706 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13708 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13710 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13712 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13716 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13718 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13720 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13722 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13724 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13728 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13730 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13732 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13734 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13736 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13740 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13742 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13743 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13745 // ok, the plan for this algorithm is the following:
13746 // we have 2 salts here, the domain-name and a random salt
13747 // while both are used in the initial transformation,
13748 // only the random salt is used in the following iterations
13749 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13750 // and one that includes only the real salt (stored into salt_buf[]).
13751 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13753 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13755 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13757 memcpy (digest
, tmp_buf
, 20);
13759 digest
[0] = byte_swap_32 (digest
[0]);
13760 digest
[1] = byte_swap_32 (digest
[1]);
13761 digest
[2] = byte_swap_32 (digest
[2]);
13762 digest
[3] = byte_swap_32 (digest
[3]);
13763 digest
[4] = byte_swap_32 (digest
[4]);
13767 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13769 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13771 char *len_ptr
= NULL
;
13773 for (uint i
= 0; i
< domainbuf_len
; i
++)
13775 if (salt_buf_pc_ptr
[i
] == '.')
13777 len_ptr
= &salt_buf_pc_ptr
[i
];
13787 salt
->salt_buf_pc
[7] = domainbuf_len
;
13791 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13793 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13795 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13797 salt
->salt_len
= salt_len
;
13801 salt
->salt_iter
= atoi (iteration_pos
);
13803 return (PARSER_OK
);
13806 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13808 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13810 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13812 salt_t
*salt
= hash_buf
->salt
;
13814 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13815 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13816 digest
[2] = hex_to_uint (&input_buf
[16]);
13817 digest
[3] = hex_to_uint (&input_buf
[24]);
13818 digest
[4] = hex_to_uint (&input_buf
[32]);
13820 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13822 uint salt_len
= input_len
- 40 - 1;
13824 char *salt_buf
= input_buf
+ 40 + 1;
13826 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13828 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13830 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13832 salt
->salt_len
= salt_len
;
13834 return (PARSER_OK
);
13837 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13839 const uint8_t ascii_to_ebcdic
[] =
13841 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13842 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13843 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13844 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13845 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13846 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13847 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13848 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13849 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13850 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13851 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13852 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13853 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13854 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13855 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13856 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13859 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13861 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13863 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13865 salt_t
*salt
= hash_buf
->salt
;
13867 char *salt_pos
= input_buf
+ 6 + 1;
13869 char *digest_pos
= strchr (salt_pos
, '*');
13871 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13873 uint salt_len
= digest_pos
- salt_pos
;
13875 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13877 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13879 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13883 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13884 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13886 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13888 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13890 salt
->salt_len
= salt_len
;
13892 for (uint i
= 0; i
< salt_len
; i
++)
13894 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13896 for (uint i
= salt_len
; i
< 8; i
++)
13898 salt_buf_pc_ptr
[i
] = 0x40;
13903 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13905 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13906 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13908 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13909 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13911 digest
[0] = byte_swap_32 (digest
[0]);
13912 digest
[1] = byte_swap_32 (digest
[1]);
13914 IP (digest
[0], digest
[1], tt
);
13916 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13917 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13921 return (PARSER_OK
);
13924 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13926 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13928 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13930 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13931 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13932 digest
[2] = hex_to_uint (&input_buf
[16]);
13933 digest
[3] = hex_to_uint (&input_buf
[24]);
13935 digest
[0] = byte_swap_32 (digest
[0]);
13936 digest
[1] = byte_swap_32 (digest
[1]);
13937 digest
[2] = byte_swap_32 (digest
[2]);
13938 digest
[3] = byte_swap_32 (digest
[3]);
13940 return (PARSER_OK
);
13943 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13945 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13947 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13949 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13951 salt_t
*salt
= hash_buf
->salt
;
13955 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13957 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13959 tmp_buf
[3] += -4; // dont ask!
13961 memcpy (salt
->salt_buf
, tmp_buf
, 5);
13963 salt
->salt_len
= 5;
13965 memcpy (digest
, tmp_buf
+ 5, 9);
13967 // yes, only 9 byte are needed to crack, but 10 to display
13969 salt
->salt_buf_pc
[7] = input_buf
[20];
13971 return (PARSER_OK
);
13974 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13976 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
13978 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) 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!
13994 memcpy (salt
->salt_buf
, tmp_buf
, 16);
13996 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)
14000 char tmp_iter_buf
[11];
14002 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14004 tmp_iter_buf
[10] = 0;
14006 salt
->salt_iter
= atoi (tmp_iter_buf
);
14008 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14010 return (PARSER_SALT_ITERATION
);
14013 salt
->salt_iter
--; // first round in init
14015 // 2 additional bytes for display only
14017 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14018 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14022 memcpy (digest
, tmp_buf
+ 28, 8);
14024 digest
[0] = byte_swap_32 (digest
[0]);
14025 digest
[1] = byte_swap_32 (digest
[1]);
14029 return (PARSER_OK
);
14032 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14034 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14036 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14038 salt_t
*salt
= hash_buf
->salt
;
14040 char *salt_buf_pos
= input_buf
;
14042 char *hash_buf_pos
= salt_buf_pos
+ 6;
14044 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14045 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14046 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14047 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14048 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14049 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14050 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14051 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14053 digest
[0] -= SHA256M_A
;
14054 digest
[1] -= SHA256M_B
;
14055 digest
[2] -= SHA256M_C
;
14056 digest
[3] -= SHA256M_D
;
14057 digest
[4] -= SHA256M_E
;
14058 digest
[5] -= SHA256M_F
;
14059 digest
[6] -= SHA256M_G
;
14060 digest
[7] -= SHA256M_H
;
14062 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14064 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14066 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14068 salt
->salt_len
= salt_len
;
14070 return (PARSER_OK
);
14073 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14075 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14077 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14079 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14081 salt_t
*salt
= hash_buf
->salt
;
14083 char *salt_buf
= input_buf
+ 6;
14085 char *digest_buf
= strchr (salt_buf
, '$');
14087 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14089 uint salt_len
= digest_buf
- salt_buf
;
14091 digest_buf
++; // skip the '$' symbol
14093 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14095 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14097 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14099 salt
->salt_len
= salt_len
;
14101 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14102 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14103 digest
[2] = hex_to_uint (&digest_buf
[16]);
14104 digest
[3] = hex_to_uint (&digest_buf
[24]);
14106 digest
[0] = byte_swap_32 (digest
[0]);
14107 digest
[1] = byte_swap_32 (digest
[1]);
14108 digest
[2] = byte_swap_32 (digest
[2]);
14109 digest
[3] = byte_swap_32 (digest
[3]);
14111 digest
[0] -= MD5M_A
;
14112 digest
[1] -= MD5M_B
;
14113 digest
[2] -= MD5M_C
;
14114 digest
[3] -= MD5M_D
;
14116 return (PARSER_OK
);
14119 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14121 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14123 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14125 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14127 salt_t
*salt
= hash_buf
->salt
;
14129 char *salt_buf
= input_buf
+ 3;
14131 char *digest_buf
= strchr (salt_buf
, '$');
14133 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14135 uint salt_len
= digest_buf
- salt_buf
;
14137 digest_buf
++; // skip the '$' symbol
14139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14141 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14143 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14145 salt_buf_ptr
[salt_len
] = 0x2d;
14147 salt
->salt_len
= salt_len
+ 1;
14149 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14150 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14151 digest
[2] = hex_to_uint (&digest_buf
[16]);
14152 digest
[3] = hex_to_uint (&digest_buf
[24]);
14154 digest
[0] = byte_swap_32 (digest
[0]);
14155 digest
[1] = byte_swap_32 (digest
[1]);
14156 digest
[2] = byte_swap_32 (digest
[2]);
14157 digest
[3] = byte_swap_32 (digest
[3]);
14159 digest
[0] -= MD5M_A
;
14160 digest
[1] -= MD5M_B
;
14161 digest
[2] -= MD5M_C
;
14162 digest
[3] -= MD5M_D
;
14164 return (PARSER_OK
);
14167 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14169 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14171 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14175 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14177 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14179 memcpy (digest
, tmp_buf
, 20);
14181 digest
[0] = byte_swap_32 (digest
[0]);
14182 digest
[1] = byte_swap_32 (digest
[1]);
14183 digest
[2] = byte_swap_32 (digest
[2]);
14184 digest
[3] = byte_swap_32 (digest
[3]);
14185 digest
[4] = byte_swap_32 (digest
[4]);
14187 digest
[0] -= SHA1M_A
;
14188 digest
[1] -= SHA1M_B
;
14189 digest
[2] -= SHA1M_C
;
14190 digest
[3] -= SHA1M_D
;
14191 digest
[4] -= SHA1M_E
;
14193 return (PARSER_OK
);
14196 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14198 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14200 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14202 salt_t
*salt
= hash_buf
->salt
;
14204 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14205 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14206 digest
[2] = hex_to_uint (&input_buf
[16]);
14207 digest
[3] = hex_to_uint (&input_buf
[24]);
14209 digest
[0] = byte_swap_32 (digest
[0]);
14210 digest
[1] = byte_swap_32 (digest
[1]);
14211 digest
[2] = byte_swap_32 (digest
[2]);
14212 digest
[3] = byte_swap_32 (digest
[3]);
14214 digest
[0] -= MD5M_A
;
14215 digest
[1] -= MD5M_B
;
14216 digest
[2] -= MD5M_C
;
14217 digest
[3] -= MD5M_D
;
14219 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14221 uint salt_len
= input_len
- 32 - 1;
14223 char *salt_buf
= input_buf
+ 32 + 1;
14225 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14227 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14229 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14232 * add static "salt" part
14235 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14239 salt
->salt_len
= salt_len
;
14241 return (PARSER_OK
);
14244 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14246 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14248 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14250 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14252 salt_t
*salt
= hash_buf
->salt
;
14254 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14260 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14262 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14264 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14266 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14268 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14272 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14274 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14276 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14278 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14282 char *keybuf_pos
= strchr (keylen_pos
, '$');
14284 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14286 uint keylen_len
= keybuf_pos
- keylen_pos
;
14288 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14292 char *databuf_pos
= strchr (keybuf_pos
, '$');
14294 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14296 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14298 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14302 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14304 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14310 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14311 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14312 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14313 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14315 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14316 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14317 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14318 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14320 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14321 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14322 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14323 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14325 salt
->salt_len
= 16;
14326 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14328 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14330 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14333 return (PARSER_OK
);
14336 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14338 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14340 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14342 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14344 salt_t
*salt
= hash_buf
->salt
;
14350 // first is the N salt parameter
14352 char *N_pos
= input_buf
+ 6;
14354 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14358 salt
->scrypt_N
= atoi (N_pos
);
14362 char *r_pos
= strchr (N_pos
, ':');
14364 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14368 salt
->scrypt_r
= atoi (r_pos
);
14372 char *p_pos
= strchr (r_pos
, ':');
14374 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14378 salt
->scrypt_p
= atoi (p_pos
);
14382 char *saltbuf_pos
= strchr (p_pos
, ':');
14384 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14388 char *hash_pos
= strchr (saltbuf_pos
, ':');
14390 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14398 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14400 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14402 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14404 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14406 salt
->salt_len
= tmp_len
;
14407 salt
->salt_iter
= 1;
14409 // digest - base64 decode
14411 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14413 tmp_len
= input_len
- (hash_pos
- input_buf
);
14415 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14417 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14419 memcpy (digest
, tmp_buf
, 32);
14421 return (PARSER_OK
);
14424 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14426 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14428 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14430 salt_t
*salt
= hash_buf
->salt
;
14436 char decrypted
[76]; // iv + hash
14438 juniper_decrypt_hash (input_buf
, decrypted
);
14440 char *md5crypt_hash
= decrypted
+ 12;
14442 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14444 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14446 char *salt_pos
= md5crypt_hash
+ 3;
14448 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14450 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14452 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14456 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14458 return (PARSER_OK
);
14461 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14463 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14465 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14467 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14469 salt_t
*salt
= hash_buf
->salt
;
14471 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14477 // first is *raw* salt
14479 char *salt_pos
= input_buf
+ 3;
14481 char *hash_pos
= strchr (salt_pos
, '$');
14483 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14485 uint salt_len
= hash_pos
- salt_pos
;
14487 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14491 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14493 memcpy (salt_buf_ptr
, salt_pos
, 14);
14495 salt_buf_ptr
[17] = 0x01;
14496 salt_buf_ptr
[18] = 0x80;
14498 // add some stuff to normal salt to make sorted happy
14500 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14501 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14502 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14503 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14505 salt
->salt_len
= salt_len
;
14506 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14508 // base64 decode hash
14512 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14514 uint hash_len
= input_len
- 3 - salt_len
- 1;
14516 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14518 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14520 memcpy (digest
, tmp_buf
, 32);
14522 digest
[0] = byte_swap_32 (digest
[0]);
14523 digest
[1] = byte_swap_32 (digest
[1]);
14524 digest
[2] = byte_swap_32 (digest
[2]);
14525 digest
[3] = byte_swap_32 (digest
[3]);
14526 digest
[4] = byte_swap_32 (digest
[4]);
14527 digest
[5] = byte_swap_32 (digest
[5]);
14528 digest
[6] = byte_swap_32 (digest
[6]);
14529 digest
[7] = byte_swap_32 (digest
[7]);
14531 return (PARSER_OK
);
14534 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14536 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14538 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14540 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14542 salt_t
*salt
= hash_buf
->salt
;
14548 // first is *raw* salt
14550 char *salt_pos
= input_buf
+ 3;
14552 char *hash_pos
= strchr (salt_pos
, '$');
14554 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14556 uint salt_len
= hash_pos
- salt_pos
;
14558 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14560 salt
->salt_len
= salt_len
;
14563 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14565 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14566 salt_buf_ptr
[salt_len
] = 0;
14568 // base64 decode hash
14572 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14574 uint hash_len
= input_len
- 3 - salt_len
- 1;
14576 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14578 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14580 memcpy (digest
, tmp_buf
, 32);
14583 salt
->scrypt_N
= 16384;
14584 salt
->scrypt_r
= 1;
14585 salt
->scrypt_p
= 1;
14586 salt
->salt_iter
= 1;
14588 return (PARSER_OK
);
14591 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14593 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14595 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14597 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14599 salt_t
*salt
= hash_buf
->salt
;
14601 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14607 char *version_pos
= input_buf
+ 8 + 1;
14609 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14611 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14613 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14615 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14617 verifierHashSize_pos
++;
14619 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14621 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14623 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14625 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14629 char *saltSize_pos
= strchr (keySize_pos
, '*');
14631 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14633 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14635 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14639 char *osalt_pos
= strchr (saltSize_pos
, '*');
14641 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14643 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14645 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14649 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14651 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14653 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14655 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14657 encryptedVerifier_pos
++;
14659 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14661 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14663 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14665 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14667 encryptedVerifierHash_pos
++;
14669 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;
14671 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14673 const uint version
= atoi (version_pos
);
14675 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14677 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14679 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14681 const uint keySize
= atoi (keySize_pos
);
14683 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14685 office2007
->keySize
= keySize
;
14687 const uint saltSize
= atoi (saltSize_pos
);
14689 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14695 salt
->salt_len
= 16;
14696 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14698 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14699 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14700 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14701 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14707 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14708 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14709 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14710 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14712 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14713 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14714 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14715 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14716 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14722 digest
[0] = office2007
->encryptedVerifierHash
[0];
14723 digest
[1] = office2007
->encryptedVerifierHash
[1];
14724 digest
[2] = office2007
->encryptedVerifierHash
[2];
14725 digest
[3] = office2007
->encryptedVerifierHash
[3];
14727 return (PARSER_OK
);
14730 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14732 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14734 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14736 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14738 salt_t
*salt
= hash_buf
->salt
;
14740 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14746 char *version_pos
= input_buf
+ 8 + 1;
14748 char *spinCount_pos
= strchr (version_pos
, '*');
14750 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14752 uint32_t version_len
= spinCount_pos
- version_pos
;
14754 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14758 char *keySize_pos
= strchr (spinCount_pos
, '*');
14760 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14762 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14764 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14768 char *saltSize_pos
= strchr (keySize_pos
, '*');
14770 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14772 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14774 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14778 char *osalt_pos
= strchr (saltSize_pos
, '*');
14780 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14782 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14784 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14788 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14790 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14792 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14794 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14796 encryptedVerifier_pos
++;
14798 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14800 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14802 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14804 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14806 encryptedVerifierHash_pos
++;
14808 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;
14810 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14812 const uint version
= atoi (version_pos
);
14814 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14816 const uint spinCount
= atoi (spinCount_pos
);
14818 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14820 const uint keySize
= atoi (keySize_pos
);
14822 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14824 const uint saltSize
= atoi (saltSize_pos
);
14826 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14832 salt
->salt_len
= 16;
14833 salt
->salt_iter
= spinCount
;
14835 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14836 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14837 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14838 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14844 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14845 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14846 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14847 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14849 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14850 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14851 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14852 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14853 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14854 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14855 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14856 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14862 digest
[0] = office2010
->encryptedVerifierHash
[0];
14863 digest
[1] = office2010
->encryptedVerifierHash
[1];
14864 digest
[2] = office2010
->encryptedVerifierHash
[2];
14865 digest
[3] = office2010
->encryptedVerifierHash
[3];
14867 return (PARSER_OK
);
14870 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14872 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14874 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14876 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14878 salt_t
*salt
= hash_buf
->salt
;
14880 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14886 char *version_pos
= input_buf
+ 8 + 1;
14888 char *spinCount_pos
= strchr (version_pos
, '*');
14890 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14892 uint32_t version_len
= spinCount_pos
- version_pos
;
14894 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14898 char *keySize_pos
= strchr (spinCount_pos
, '*');
14900 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14902 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14904 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14908 char *saltSize_pos
= strchr (keySize_pos
, '*');
14910 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14912 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14914 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14918 char *osalt_pos
= strchr (saltSize_pos
, '*');
14920 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14922 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14924 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14928 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14930 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14932 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14934 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14936 encryptedVerifier_pos
++;
14938 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14940 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14942 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14944 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14946 encryptedVerifierHash_pos
++;
14948 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;
14950 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14952 const uint version
= atoi (version_pos
);
14954 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14956 const uint spinCount
= atoi (spinCount_pos
);
14958 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14960 const uint keySize
= atoi (keySize_pos
);
14962 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
14964 const uint saltSize
= atoi (saltSize_pos
);
14966 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14972 salt
->salt_len
= 16;
14973 salt
->salt_iter
= spinCount
;
14975 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14976 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14977 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14978 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14984 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14985 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14986 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14987 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14989 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14990 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14991 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14992 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14993 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14994 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14995 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14996 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15002 digest
[0] = office2013
->encryptedVerifierHash
[0];
15003 digest
[1] = office2013
->encryptedVerifierHash
[1];
15004 digest
[2] = office2013
->encryptedVerifierHash
[2];
15005 digest
[3] = office2013
->encryptedVerifierHash
[3];
15007 return (PARSER_OK
);
15010 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15012 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15014 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15016 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15018 salt_t
*salt
= hash_buf
->salt
;
15020 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15026 char *version_pos
= input_buf
+ 11;
15028 char *osalt_pos
= strchr (version_pos
, '*');
15030 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15032 uint32_t version_len
= osalt_pos
- version_pos
;
15034 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15038 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15040 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15042 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15044 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15046 encryptedVerifier_pos
++;
15048 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15050 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15052 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15054 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15056 encryptedVerifierHash_pos
++;
15058 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15060 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15062 const uint version
= *version_pos
- 0x30;
15064 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15070 oldoffice01
->version
= version
;
15072 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15073 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15074 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15075 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15077 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15078 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15079 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15080 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15082 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15083 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15084 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15085 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15087 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15088 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15089 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15090 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15096 salt
->salt_len
= 16;
15098 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15099 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15100 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15101 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15103 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15104 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15105 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15106 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15108 // this is a workaround as office produces multiple documents with the same salt
15110 salt
->salt_len
+= 32;
15112 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15113 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15114 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15115 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15116 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15117 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15118 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15119 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15125 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15126 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15127 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15128 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15130 return (PARSER_OK
);
15133 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15135 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15138 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15140 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15142 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15144 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15146 salt_t
*salt
= hash_buf
->salt
;
15148 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15154 char *version_pos
= input_buf
+ 11;
15156 char *osalt_pos
= strchr (version_pos
, '*');
15158 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15160 uint32_t version_len
= osalt_pos
- version_pos
;
15162 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15166 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15168 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15170 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15172 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15174 encryptedVerifier_pos
++;
15176 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15178 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15180 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15182 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15184 encryptedVerifierHash_pos
++;
15186 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15188 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15190 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15192 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15196 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15198 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15200 const uint version
= *version_pos
- 0x30;
15202 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15208 oldoffice01
->version
= version
;
15210 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15211 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15212 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15213 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15215 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15216 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15217 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15218 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15220 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15221 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15222 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15223 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15225 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15226 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15227 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15228 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15230 oldoffice01
->rc4key
[1] = 0;
15231 oldoffice01
->rc4key
[0] = 0;
15233 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15234 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15235 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15236 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15237 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15238 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15239 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15240 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15241 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15242 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15244 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15245 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15251 salt
->salt_len
= 16;
15253 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15254 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15255 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15256 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15258 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15259 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15260 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15261 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15263 // this is a workaround as office produces multiple documents with the same salt
15265 salt
->salt_len
+= 32;
15267 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15268 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15269 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15270 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15271 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15272 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15273 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15274 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15280 digest
[0] = oldoffice01
->rc4key
[0];
15281 digest
[1] = oldoffice01
->rc4key
[1];
15285 return (PARSER_OK
);
15288 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15290 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15292 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15294 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15296 salt_t
*salt
= hash_buf
->salt
;
15298 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15304 char *version_pos
= input_buf
+ 11;
15306 char *osalt_pos
= strchr (version_pos
, '*');
15308 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15310 uint32_t version_len
= osalt_pos
- version_pos
;
15312 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15316 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15318 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15320 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15322 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15324 encryptedVerifier_pos
++;
15326 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15328 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15330 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15332 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15334 encryptedVerifierHash_pos
++;
15336 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15338 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15340 const uint version
= *version_pos
- 0x30;
15342 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15348 oldoffice34
->version
= version
;
15350 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15351 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15352 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15353 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15355 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15356 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15357 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15358 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15360 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15361 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15362 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15363 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15364 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15366 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15367 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15368 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15369 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15370 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15376 salt
->salt_len
= 16;
15378 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15379 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15380 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15381 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15383 // this is a workaround as office produces multiple documents with the same salt
15385 salt
->salt_len
+= 32;
15387 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15388 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15389 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15390 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15391 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15392 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15393 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15394 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15400 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15401 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15402 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15403 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15405 return (PARSER_OK
);
15408 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15410 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15412 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15415 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15417 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15419 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15421 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15423 salt_t
*salt
= hash_buf
->salt
;
15425 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15431 char *version_pos
= input_buf
+ 11;
15433 char *osalt_pos
= strchr (version_pos
, '*');
15435 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15437 uint32_t version_len
= osalt_pos
- version_pos
;
15439 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15443 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15445 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15447 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15449 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15451 encryptedVerifier_pos
++;
15453 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15455 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15457 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15459 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15461 encryptedVerifierHash_pos
++;
15463 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15465 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15467 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15469 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15473 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15475 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15477 const uint version
= *version_pos
- 0x30;
15479 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15485 oldoffice34
->version
= version
;
15487 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15488 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15489 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15490 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15492 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15493 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15494 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15495 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15497 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15498 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15499 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15500 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15501 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15503 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15504 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15505 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15506 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15507 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15509 oldoffice34
->rc4key
[1] = 0;
15510 oldoffice34
->rc4key
[0] = 0;
15512 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15513 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15514 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15515 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15516 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15517 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15518 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15519 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15520 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15521 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15523 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15524 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15530 salt
->salt_len
= 16;
15532 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15533 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15534 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15535 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15537 // this is a workaround as office produces multiple documents with the same salt
15539 salt
->salt_len
+= 32;
15541 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15542 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15543 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15544 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15545 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15546 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15547 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15548 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15554 digest
[0] = oldoffice34
->rc4key
[0];
15555 digest
[1] = oldoffice34
->rc4key
[1];
15559 return (PARSER_OK
);
15562 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15564 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15566 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15568 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15569 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15570 digest
[2] = hex_to_uint (&input_buf
[16]);
15571 digest
[3] = hex_to_uint (&input_buf
[24]);
15573 digest
[0] = byte_swap_32 (digest
[0]);
15574 digest
[1] = byte_swap_32 (digest
[1]);
15575 digest
[2] = byte_swap_32 (digest
[2]);
15576 digest
[3] = byte_swap_32 (digest
[3]);
15578 return (PARSER_OK
);
15581 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15583 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15585 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15587 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15589 salt_t
*salt
= hash_buf
->salt
;
15591 char *signature_pos
= input_buf
;
15593 char *salt_pos
= strchr (signature_pos
, '$');
15595 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15597 uint32_t signature_len
= salt_pos
- signature_pos
;
15599 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15603 char *hash_pos
= strchr (salt_pos
, '$');
15605 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15607 uint32_t salt_len
= hash_pos
- salt_pos
;
15609 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15613 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15615 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15617 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15618 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15619 digest
[2] = hex_to_uint (&hash_pos
[16]);
15620 digest
[3] = hex_to_uint (&hash_pos
[24]);
15621 digest
[4] = hex_to_uint (&hash_pos
[32]);
15623 digest
[0] -= SHA1M_A
;
15624 digest
[1] -= SHA1M_B
;
15625 digest
[2] -= SHA1M_C
;
15626 digest
[3] -= SHA1M_D
;
15627 digest
[4] -= SHA1M_E
;
15629 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15631 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15633 salt
->salt_len
= salt_len
;
15635 return (PARSER_OK
);
15638 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15640 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15642 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15644 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15646 salt_t
*salt
= hash_buf
->salt
;
15648 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15654 char *iter_pos
= input_buf
+ 14;
15656 const int iter
= atoi (iter_pos
);
15658 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15660 salt
->salt_iter
= iter
- 1;
15662 char *salt_pos
= strchr (iter_pos
, '$');
15664 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15668 char *hash_pos
= strchr (salt_pos
, '$');
15670 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15672 const uint salt_len
= hash_pos
- salt_pos
;
15676 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15678 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15680 salt
->salt_len
= salt_len
;
15682 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15683 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15685 // add some stuff to normal salt to make sorted happy
15687 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15688 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15689 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15690 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15691 salt
->salt_buf
[4] = salt
->salt_iter
;
15693 // base64 decode hash
15697 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15699 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15701 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15703 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15705 memcpy (digest
, tmp_buf
, 32);
15707 digest
[0] = byte_swap_32 (digest
[0]);
15708 digest
[1] = byte_swap_32 (digest
[1]);
15709 digest
[2] = byte_swap_32 (digest
[2]);
15710 digest
[3] = byte_swap_32 (digest
[3]);
15711 digest
[4] = byte_swap_32 (digest
[4]);
15712 digest
[5] = byte_swap_32 (digest
[5]);
15713 digest
[6] = byte_swap_32 (digest
[6]);
15714 digest
[7] = byte_swap_32 (digest
[7]);
15716 return (PARSER_OK
);
15719 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15721 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15723 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15725 salt_t
*salt
= hash_buf
->salt
;
15727 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15728 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15732 digest
[0] = byte_swap_32 (digest
[0]);
15733 digest
[1] = byte_swap_32 (digest
[1]);
15735 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15736 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15737 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15739 char iter_c
= input_buf
[17];
15740 char iter_d
= input_buf
[19];
15742 // atm only defaults, let's see if there's more request
15743 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15744 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15746 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15748 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15749 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15750 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15751 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15753 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15754 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15755 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15756 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15758 salt
->salt_len
= 16;
15760 return (PARSER_OK
);
15763 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15765 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15767 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15769 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15771 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15773 salt_t
*salt
= hash_buf
->salt
;
15775 char *salt_pos
= input_buf
+ 10;
15777 char *hash_pos
= strchr (salt_pos
, '$');
15779 uint salt_len
= hash_pos
- salt_pos
;
15781 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15785 uint hash_len
= input_len
- 10 - salt_len
- 1;
15787 // base64 decode salt
15791 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15793 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15795 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15797 tmp_buf
[salt_len
] = 0x80;
15799 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15801 salt
->salt_len
= salt_len
;
15803 // base64 decode salt
15805 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15807 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15809 uint user_len
= hash_len
- 32;
15811 char *tmp_hash
= tmp_buf
+ user_len
;
15813 user_len
--; // skip the trailing space
15815 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15816 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15817 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15818 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15820 digest
[0] = byte_swap_32 (digest
[0]);
15821 digest
[1] = byte_swap_32 (digest
[1]);
15822 digest
[2] = byte_swap_32 (digest
[2]);
15823 digest
[3] = byte_swap_32 (digest
[3]);
15825 // store username for host only (output hash if cracked)
15827 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15828 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15830 return (PARSER_OK
);
15833 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15835 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15837 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15839 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15841 salt_t
*salt
= hash_buf
->salt
;
15843 char *iter_pos
= input_buf
+ 10;
15845 uint32_t iter
= atoi (iter_pos
);
15849 return (PARSER_SALT_ITERATION
);
15852 iter
--; // first iteration is special
15854 salt
->salt_iter
= iter
;
15856 char *base64_pos
= strchr (iter_pos
, '}');
15858 if (base64_pos
== NULL
)
15860 return (PARSER_SIGNATURE_UNMATCHED
);
15865 // base64 decode salt
15867 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15871 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15873 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15875 if (decoded_len
< 24)
15877 return (PARSER_SALT_LENGTH
);
15882 uint salt_len
= decoded_len
- 20;
15884 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15885 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15887 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15889 salt
->salt_len
= salt_len
;
15893 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15895 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15896 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15897 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15898 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15899 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15901 return (PARSER_OK
);
15904 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15906 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15908 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15910 salt_t
*salt
= hash_buf
->salt
;
15912 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15913 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15914 digest
[2] = hex_to_uint (&input_buf
[16]);
15915 digest
[3] = hex_to_uint (&input_buf
[24]);
15916 digest
[4] = hex_to_uint (&input_buf
[32]);
15918 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15920 uint salt_len
= input_len
- 40 - 1;
15922 char *salt_buf
= input_buf
+ 40 + 1;
15924 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15926 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15928 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15930 salt
->salt_len
= salt_len
;
15932 return (PARSER_OK
);
15935 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15937 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15939 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15941 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15943 salt_t
*salt
= hash_buf
->salt
;
15945 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15951 char *V_pos
= input_buf
+ 5;
15953 char *R_pos
= strchr (V_pos
, '*');
15955 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15957 uint32_t V_len
= R_pos
- V_pos
;
15961 char *bits_pos
= strchr (R_pos
, '*');
15963 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15965 uint32_t R_len
= bits_pos
- R_pos
;
15969 char *P_pos
= strchr (bits_pos
, '*');
15971 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15973 uint32_t bits_len
= P_pos
- bits_pos
;
15977 char *enc_md_pos
= strchr (P_pos
, '*');
15979 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15981 uint32_t P_len
= enc_md_pos
- P_pos
;
15985 char *id_len_pos
= strchr (enc_md_pos
, '*');
15987 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15989 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
15993 char *id_buf_pos
= strchr (id_len_pos
, '*');
15995 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15997 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16001 char *u_len_pos
= strchr (id_buf_pos
, '*');
16003 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16005 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16007 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16011 char *u_buf_pos
= strchr (u_len_pos
, '*');
16013 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16015 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16019 char *o_len_pos
= strchr (u_buf_pos
, '*');
16021 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16023 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16025 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16029 char *o_buf_pos
= strchr (o_len_pos
, '*');
16031 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16033 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16037 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;
16039 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16043 const int V
= atoi (V_pos
);
16044 const int R
= atoi (R_pos
);
16045 const int P
= atoi (P_pos
);
16047 if (V
!= 1) return (PARSER_SALT_VALUE
);
16048 if (R
!= 2) return (PARSER_SALT_VALUE
);
16050 const int enc_md
= atoi (enc_md_pos
);
16052 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16054 const int id_len
= atoi (id_len_pos
);
16055 const int u_len
= atoi (u_len_pos
);
16056 const int o_len
= atoi (o_len_pos
);
16058 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16059 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16060 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16062 const int bits
= atoi (bits_pos
);
16064 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16066 // copy data to esalt
16072 pdf
->enc_md
= enc_md
;
16074 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16075 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16076 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16077 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16078 pdf
->id_len
= id_len
;
16080 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16081 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16082 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16083 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16084 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16085 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16086 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16087 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16088 pdf
->u_len
= u_len
;
16090 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16091 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16092 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16093 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16094 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16095 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16096 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16097 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16098 pdf
->o_len
= o_len
;
16100 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16101 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16102 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16103 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16105 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16106 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16107 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16108 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16109 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16110 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16111 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16112 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16114 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16115 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16116 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16117 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16118 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16119 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16120 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16121 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16123 // we use ID for salt, maybe needs to change, we will see...
16125 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16126 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16127 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16128 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16129 salt
->salt_len
= pdf
->id_len
;
16131 digest
[0] = pdf
->u_buf
[0];
16132 digest
[1] = pdf
->u_buf
[1];
16133 digest
[2] = pdf
->u_buf
[2];
16134 digest
[3] = pdf
->u_buf
[3];
16136 return (PARSER_OK
);
16139 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16141 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16144 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16146 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16148 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16150 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16152 salt_t
*salt
= hash_buf
->salt
;
16154 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16160 char *V_pos
= input_buf
+ 5;
16162 char *R_pos
= strchr (V_pos
, '*');
16164 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16166 uint32_t V_len
= R_pos
- V_pos
;
16170 char *bits_pos
= strchr (R_pos
, '*');
16172 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16174 uint32_t R_len
= bits_pos
- R_pos
;
16178 char *P_pos
= strchr (bits_pos
, '*');
16180 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16182 uint32_t bits_len
= P_pos
- bits_pos
;
16186 char *enc_md_pos
= strchr (P_pos
, '*');
16188 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16190 uint32_t P_len
= enc_md_pos
- P_pos
;
16194 char *id_len_pos
= strchr (enc_md_pos
, '*');
16196 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16198 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16202 char *id_buf_pos
= strchr (id_len_pos
, '*');
16204 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16206 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16210 char *u_len_pos
= strchr (id_buf_pos
, '*');
16212 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16214 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16216 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16220 char *u_buf_pos
= strchr (u_len_pos
, '*');
16222 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16224 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16228 char *o_len_pos
= strchr (u_buf_pos
, '*');
16230 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16232 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16234 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16238 char *o_buf_pos
= strchr (o_len_pos
, '*');
16240 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16242 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16246 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16248 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16250 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16252 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16256 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;
16258 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16262 const int V
= atoi (V_pos
);
16263 const int R
= atoi (R_pos
);
16264 const int P
= atoi (P_pos
);
16266 if (V
!= 1) return (PARSER_SALT_VALUE
);
16267 if (R
!= 2) return (PARSER_SALT_VALUE
);
16269 const int enc_md
= atoi (enc_md_pos
);
16271 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16273 const int id_len
= atoi (id_len_pos
);
16274 const int u_len
= atoi (u_len_pos
);
16275 const int o_len
= atoi (o_len_pos
);
16277 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16278 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16279 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16281 const int bits
= atoi (bits_pos
);
16283 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16285 // copy data to esalt
16291 pdf
->enc_md
= enc_md
;
16293 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16294 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16295 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16296 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16297 pdf
->id_len
= id_len
;
16299 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16300 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16301 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16302 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16303 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16304 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16305 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16306 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16307 pdf
->u_len
= u_len
;
16309 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16310 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16311 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16312 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16313 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16314 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16315 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16316 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16317 pdf
->o_len
= o_len
;
16319 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16320 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16321 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16322 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16324 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16325 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16326 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16327 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16328 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16329 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16330 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16331 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16333 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16334 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16335 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16336 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16337 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16338 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16339 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16340 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16342 pdf
->rc4key
[1] = 0;
16343 pdf
->rc4key
[0] = 0;
16345 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16346 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16347 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16348 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16349 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16350 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16351 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16352 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16353 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16354 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16356 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16357 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16359 // we use ID for salt, maybe needs to change, we will see...
16361 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16362 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16363 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16364 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16365 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16366 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16367 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16368 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16369 salt
->salt_len
= pdf
->id_len
+ 16;
16371 digest
[0] = pdf
->rc4key
[0];
16372 digest
[1] = pdf
->rc4key
[1];
16376 return (PARSER_OK
);
16379 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16381 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16383 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16385 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16387 salt_t
*salt
= hash_buf
->salt
;
16389 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16395 char *V_pos
= input_buf
+ 5;
16397 char *R_pos
= strchr (V_pos
, '*');
16399 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16401 uint32_t V_len
= R_pos
- V_pos
;
16405 char *bits_pos
= strchr (R_pos
, '*');
16407 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16409 uint32_t R_len
= bits_pos
- R_pos
;
16413 char *P_pos
= strchr (bits_pos
, '*');
16415 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16417 uint32_t bits_len
= P_pos
- bits_pos
;
16421 char *enc_md_pos
= strchr (P_pos
, '*');
16423 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16425 uint32_t P_len
= enc_md_pos
- P_pos
;
16429 char *id_len_pos
= strchr (enc_md_pos
, '*');
16431 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16433 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16437 char *id_buf_pos
= strchr (id_len_pos
, '*');
16439 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16441 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16445 char *u_len_pos
= strchr (id_buf_pos
, '*');
16447 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16449 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16451 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16455 char *u_buf_pos
= strchr (u_len_pos
, '*');
16457 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16459 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16463 char *o_len_pos
= strchr (u_buf_pos
, '*');
16465 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16467 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16469 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16473 char *o_buf_pos
= strchr (o_len_pos
, '*');
16475 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16477 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16481 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;
16483 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16487 const int V
= atoi (V_pos
);
16488 const int R
= atoi (R_pos
);
16489 const int P
= atoi (P_pos
);
16493 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16494 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16496 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16498 const int id_len
= atoi (id_len_pos
);
16499 const int u_len
= atoi (u_len_pos
);
16500 const int o_len
= atoi (o_len_pos
);
16502 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16504 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16505 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16507 const int bits
= atoi (bits_pos
);
16509 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16515 enc_md
= atoi (enc_md_pos
);
16518 // copy data to esalt
16524 pdf
->enc_md
= enc_md
;
16526 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16527 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16528 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16529 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16533 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16534 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16535 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16536 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16539 pdf
->id_len
= id_len
;
16541 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16542 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16543 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16544 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16545 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16546 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16547 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16548 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16549 pdf
->u_len
= u_len
;
16551 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16552 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16553 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16554 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16555 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16556 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16557 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16558 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16559 pdf
->o_len
= o_len
;
16561 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16562 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16563 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16564 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16568 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16569 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16570 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16571 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16574 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16575 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16576 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16577 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16578 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16579 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16580 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16581 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16583 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16584 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16585 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16586 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16587 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16588 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16589 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16590 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16592 // precompute rc4 data for later use
16608 uint salt_pc_block
[32];
16610 char *salt_pc_ptr
= (char *) salt_pc_block
;
16612 memcpy (salt_pc_ptr
, padding
, 32);
16613 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16615 uint salt_pc_digest
[4];
16617 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16619 pdf
->rc4data
[0] = salt_pc_digest
[0];
16620 pdf
->rc4data
[1] = salt_pc_digest
[1];
16622 // we use ID for salt, maybe needs to change, we will see...
16624 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16625 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16626 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16627 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16628 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16629 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16630 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16631 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16632 salt
->salt_len
= pdf
->id_len
+ 16;
16634 salt
->salt_iter
= ROUNDS_PDF14
;
16636 digest
[0] = pdf
->u_buf
[0];
16637 digest
[1] = pdf
->u_buf
[1];
16641 return (PARSER_OK
);
16644 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16646 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16648 if (ret
!= PARSER_OK
)
16653 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16655 salt_t
*salt
= hash_buf
->salt
;
16657 digest
[0] -= SHA256M_A
;
16658 digest
[1] -= SHA256M_B
;
16659 digest
[2] -= SHA256M_C
;
16660 digest
[3] -= SHA256M_D
;
16661 digest
[4] -= SHA256M_E
;
16662 digest
[5] -= SHA256M_F
;
16663 digest
[6] -= SHA256M_G
;
16664 digest
[7] -= SHA256M_H
;
16666 salt
->salt_buf
[2] = 0x80;
16668 return (PARSER_OK
);
16671 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16673 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16675 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16677 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16679 salt_t
*salt
= hash_buf
->salt
;
16681 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16687 char *V_pos
= input_buf
+ 5;
16689 char *R_pos
= strchr (V_pos
, '*');
16691 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16693 uint32_t V_len
= R_pos
- V_pos
;
16697 char *bits_pos
= strchr (R_pos
, '*');
16699 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16701 uint32_t R_len
= bits_pos
- R_pos
;
16705 char *P_pos
= strchr (bits_pos
, '*');
16707 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16709 uint32_t bits_len
= P_pos
- bits_pos
;
16713 char *enc_md_pos
= strchr (P_pos
, '*');
16715 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16717 uint32_t P_len
= enc_md_pos
- P_pos
;
16721 char *id_len_pos
= strchr (enc_md_pos
, '*');
16723 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16725 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16729 char *id_buf_pos
= strchr (id_len_pos
, '*');
16731 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16733 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16737 char *u_len_pos
= strchr (id_buf_pos
, '*');
16739 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16741 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16745 char *u_buf_pos
= strchr (u_len_pos
, '*');
16747 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16749 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16753 char *o_len_pos
= strchr (u_buf_pos
, '*');
16755 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16757 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16761 char *o_buf_pos
= strchr (o_len_pos
, '*');
16763 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16765 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16769 char *last
= strchr (o_buf_pos
, '*');
16771 if (last
== NULL
) last
= input_buf
+ input_len
;
16773 uint32_t o_buf_len
= last
- o_buf_pos
;
16777 const int V
= atoi (V_pos
);
16778 const int R
= atoi (R_pos
);
16782 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16783 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16785 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16787 const int bits
= atoi (bits_pos
);
16789 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16791 int enc_md
= atoi (enc_md_pos
);
16793 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16795 const uint id_len
= atoi (id_len_pos
);
16796 const uint u_len
= atoi (u_len_pos
);
16797 const uint o_len
= atoi (o_len_pos
);
16799 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16800 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16801 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16802 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16803 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16804 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16805 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16806 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16808 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16809 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16810 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16812 // copy data to esalt
16814 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16816 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16818 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16821 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16822 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16824 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16825 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16827 salt
->salt_len
= 8;
16828 salt
->salt_iter
= ROUNDS_PDF17L8
;
16830 digest
[0] = pdf
->u_buf
[0];
16831 digest
[1] = pdf
->u_buf
[1];
16832 digest
[2] = pdf
->u_buf
[2];
16833 digest
[3] = pdf
->u_buf
[3];
16834 digest
[4] = pdf
->u_buf
[4];
16835 digest
[5] = pdf
->u_buf
[5];
16836 digest
[6] = pdf
->u_buf
[6];
16837 digest
[7] = pdf
->u_buf
[7];
16839 return (PARSER_OK
);
16842 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16844 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16846 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16848 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16850 salt_t
*salt
= hash_buf
->salt
;
16852 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16860 char *iter_pos
= input_buf
+ 7;
16862 uint32_t iter
= atoi (iter_pos
);
16864 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16865 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16867 // first is *raw* salt
16869 char *salt_pos
= strchr (iter_pos
, ':');
16871 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16875 char *hash_pos
= strchr (salt_pos
, ':');
16877 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16879 uint32_t salt_len
= hash_pos
- salt_pos
;
16881 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16885 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16887 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16891 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16893 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16895 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16897 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16898 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16900 salt
->salt_len
= salt_len
;
16901 salt
->salt_iter
= iter
- 1;
16907 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16909 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16911 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16913 memcpy (digest
, tmp_buf
, 16);
16915 digest
[0] = byte_swap_32 (digest
[0]);
16916 digest
[1] = byte_swap_32 (digest
[1]);
16917 digest
[2] = byte_swap_32 (digest
[2]);
16918 digest
[3] = byte_swap_32 (digest
[3]);
16920 // add some stuff to normal salt to make sorted happy
16922 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16923 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16924 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16925 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16926 salt
->salt_buf
[4] = salt
->salt_iter
;
16928 return (PARSER_OK
);
16931 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16933 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16935 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16937 salt_t
*salt
= hash_buf
->salt
;
16939 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16940 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16941 digest
[2] = hex_to_uint (&input_buf
[16]);
16942 digest
[3] = hex_to_uint (&input_buf
[24]);
16944 digest
[0] = byte_swap_32 (digest
[0]);
16945 digest
[1] = byte_swap_32 (digest
[1]);
16946 digest
[2] = byte_swap_32 (digest
[2]);
16947 digest
[3] = byte_swap_32 (digest
[3]);
16949 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16951 uint salt_len
= input_len
- 32 - 1;
16953 char *salt_buf
= input_buf
+ 32 + 1;
16955 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16957 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16959 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16961 salt
->salt_len
= salt_len
;
16963 return (PARSER_OK
);
16966 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16968 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
16970 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16972 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16974 salt_t
*salt
= hash_buf
->salt
;
16976 char *user_pos
= input_buf
+ 10;
16978 char *salt_pos
= strchr (user_pos
, '*');
16980 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16984 char *hash_pos
= strchr (salt_pos
, '*');
16988 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16990 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
16992 uint user_len
= salt_pos
- user_pos
- 1;
16994 uint salt_len
= hash_pos
- salt_pos
- 1;
16996 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17002 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17003 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17004 digest
[2] = hex_to_uint (&hash_pos
[16]);
17005 digest
[3] = hex_to_uint (&hash_pos
[24]);
17007 digest
[0] = byte_swap_32 (digest
[0]);
17008 digest
[1] = byte_swap_32 (digest
[1]);
17009 digest
[2] = byte_swap_32 (digest
[2]);
17010 digest
[3] = byte_swap_32 (digest
[3]);
17012 digest
[0] -= MD5M_A
;
17013 digest
[1] -= MD5M_B
;
17014 digest
[2] -= MD5M_C
;
17015 digest
[3] -= MD5M_D
;
17021 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17023 // first 4 bytes are the "challenge"
17025 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17026 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17027 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17028 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17030 // append the user name
17032 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17034 salt
->salt_len
= 4 + user_len
;
17036 return (PARSER_OK
);
17039 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17041 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17043 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17045 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17047 salt_t
*salt
= hash_buf
->salt
;
17049 char *salt_pos
= input_buf
+ 9;
17051 char *hash_pos
= strchr (salt_pos
, '*');
17053 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17057 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17059 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17061 uint salt_len
= hash_pos
- salt_pos
- 1;
17063 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17069 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17070 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17071 digest
[2] = hex_to_uint (&hash_pos
[16]);
17072 digest
[3] = hex_to_uint (&hash_pos
[24]);
17073 digest
[4] = hex_to_uint (&hash_pos
[32]);
17079 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17081 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17083 salt
->salt_len
= salt_len
;
17085 return (PARSER_OK
);
17088 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17090 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17092 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17094 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17096 salt_t
*salt
= hash_buf
->salt
;
17098 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17104 char *cry_master_len_pos
= input_buf
+ 9;
17106 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17108 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17110 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17112 cry_master_buf_pos
++;
17114 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17116 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17118 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17120 cry_salt_len_pos
++;
17122 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17124 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17126 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17128 cry_salt_buf_pos
++;
17130 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17132 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17134 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17138 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17140 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17142 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17146 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17148 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17150 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17154 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17156 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17158 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17160 public_key_len_pos
++;
17162 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17164 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17166 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17168 public_key_buf_pos
++;
17170 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;
17172 const uint cry_master_len
= atoi (cry_master_len_pos
);
17173 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17174 const uint ckey_len
= atoi (ckey_len_pos
);
17175 const uint public_key_len
= atoi (public_key_len_pos
);
17177 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17178 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17179 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17180 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17182 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17184 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17186 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17189 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17191 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17193 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17196 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17198 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17200 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17203 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17204 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17205 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17208 * store digest (should be unique enought, hopefully)
17211 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17212 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17213 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17214 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17220 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17222 const uint cry_rounds
= atoi (cry_rounds_pos
);
17224 salt
->salt_iter
= cry_rounds
- 1;
17226 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17228 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17230 salt
->salt_len
= salt_len
;
17232 return (PARSER_OK
);
17235 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17237 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17239 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17241 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17243 salt_t
*salt
= hash_buf
->salt
;
17245 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17247 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17249 char temp_input_buf
[input_len
+ 1];
17251 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17252 memcpy (temp_input_buf
, input_buf
, input_len
);
17256 char *URI_server_pos
= temp_input_buf
+ 6;
17258 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17260 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17262 URI_client_pos
[0] = 0;
17265 uint URI_server_len
= strlen (URI_server_pos
);
17267 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17271 char *user_pos
= strchr (URI_client_pos
, '*');
17273 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17278 uint URI_client_len
= strlen (URI_client_pos
);
17280 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17284 char *realm_pos
= strchr (user_pos
, '*');
17286 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17291 uint user_len
= strlen (user_pos
);
17293 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17297 char *method_pos
= strchr (realm_pos
, '*');
17299 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 uint realm_len
= strlen (realm_pos
);
17306 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17310 char *URI_prefix_pos
= strchr (method_pos
, '*');
17312 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17314 URI_prefix_pos
[0] = 0;
17317 uint method_len
= strlen (method_pos
);
17319 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17323 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17325 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17327 URI_resource_pos
[0] = 0;
17328 URI_resource_pos
++;
17330 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17332 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17336 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17338 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17340 URI_suffix_pos
[0] = 0;
17343 uint URI_resource_len
= strlen (URI_resource_pos
);
17345 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17346 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17350 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17352 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17357 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17359 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17363 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17365 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17367 nonce_client_pos
[0] = 0;
17368 nonce_client_pos
++;
17370 uint nonce_len
= strlen (nonce_pos
);
17372 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17373 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17377 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17379 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17381 nonce_count_pos
[0] = 0;
17384 uint nonce_client_len
= strlen (nonce_client_pos
);
17386 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17390 char *qop_pos
= strchr (nonce_count_pos
, '*');
17392 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17397 uint nonce_count_len
= strlen (nonce_count_pos
);
17399 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17403 char *directive_pos
= strchr (qop_pos
, '*');
17405 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17407 directive_pos
[0] = 0;
17410 uint qop_len
= strlen (qop_pos
);
17412 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17416 char *digest_pos
= strchr (directive_pos
, '*');
17418 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17423 uint directive_len
= strlen (directive_pos
);
17425 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17427 if (memcmp (directive_pos
, "MD5", 3))
17429 log_info ("ERROR: only the MD5 directive is currently supported\n");
17431 return (PARSER_SIP_AUTH_DIRECTIVE
);
17435 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17440 uint md5_max_len
= 4 * 64;
17442 uint md5_remaining_len
= md5_max_len
;
17444 uint tmp_md5_buf
[md5_max_len
/ 4];
17446 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17448 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17450 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17452 md5_len
+= method_len
+ 1;
17453 tmp_md5_ptr
+= method_len
+ 1;
17455 if (URI_prefix_len
> 0)
17457 md5_remaining_len
= md5_max_len
- md5_len
;
17459 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17461 md5_len
+= URI_prefix_len
+ 1;
17462 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17465 md5_remaining_len
= md5_max_len
- md5_len
;
17467 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17469 md5_len
+= URI_resource_len
;
17470 tmp_md5_ptr
+= URI_resource_len
;
17472 if (URI_suffix_len
> 0)
17474 md5_remaining_len
= md5_max_len
- md5_len
;
17476 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17478 md5_len
+= 1 + URI_suffix_len
;
17481 uint tmp_digest
[4];
17483 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17485 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17486 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17487 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17488 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17494 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17496 uint esalt_len
= 0;
17498 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17500 // there are 2 possibilities for the esalt:
17502 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17504 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17506 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17508 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17520 esalt_len
= 1 + nonce_len
+ 1 + 32;
17522 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17524 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17532 // add 0x80 to esalt
17534 esalt_buf_ptr
[esalt_len
] = 0x80;
17536 sip
->esalt_len
= esalt_len
;
17542 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17544 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17546 uint max_salt_len
= 119;
17548 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17550 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17552 sip
->salt_len
= salt_len
;
17555 * fake salt (for sorting)
17558 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17562 uint fake_salt_len
= salt_len
;
17564 if (fake_salt_len
> max_salt_len
)
17566 fake_salt_len
= max_salt_len
;
17569 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17571 salt
->salt_len
= fake_salt_len
;
17577 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17578 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17579 digest
[2] = hex_to_uint (&digest_pos
[16]);
17580 digest
[3] = hex_to_uint (&digest_pos
[24]);
17582 digest
[0] = byte_swap_32 (digest
[0]);
17583 digest
[1] = byte_swap_32 (digest
[1]);
17584 digest
[2] = byte_swap_32 (digest
[2]);
17585 digest
[3] = byte_swap_32 (digest
[3]);
17587 return (PARSER_OK
);
17590 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17592 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17594 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17596 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17598 salt_t
*salt
= hash_buf
->salt
;
17602 char *digest_pos
= input_buf
;
17604 digest
[0] = hex_to_uint (&digest_pos
[0]);
17611 char *salt_buf
= input_buf
+ 8 + 1;
17615 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17617 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17619 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17621 salt
->salt_len
= salt_len
;
17623 return (PARSER_OK
);
17626 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17628 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17630 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17632 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17634 salt_t
*salt
= hash_buf
->salt
;
17636 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17642 char *p_buf_pos
= input_buf
+ 4;
17644 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17646 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17648 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17650 NumCyclesPower_pos
++;
17652 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17654 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17656 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17660 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17662 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17664 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17668 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17670 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17672 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17676 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17678 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17680 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17684 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17686 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17688 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17692 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17694 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17696 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17700 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17702 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17704 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17708 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17710 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17712 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17716 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;
17718 const uint iter
= atoi (NumCyclesPower_pos
);
17719 const uint crc
= atoi (crc_buf_pos
);
17720 const uint p_buf
= atoi (p_buf_pos
);
17721 const uint salt_len
= atoi (salt_len_pos
);
17722 const uint iv_len
= atoi (iv_len_pos
);
17723 const uint unpack_size
= atoi (unpack_size_pos
);
17724 const uint data_len
= atoi (data_len_pos
);
17730 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17731 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17733 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17735 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17737 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17743 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17744 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17745 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17746 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17748 seven_zip
->iv_len
= iv_len
;
17750 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17752 seven_zip
->salt_len
= 0;
17754 seven_zip
->crc
= crc
;
17756 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17758 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17760 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17763 seven_zip
->data_len
= data_len
;
17765 seven_zip
->unpack_size
= unpack_size
;
17769 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17770 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17771 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17772 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17774 salt
->salt_len
= 16;
17776 salt
->salt_sign
[0] = iter
;
17778 salt
->salt_iter
= 1 << iter
;
17789 return (PARSER_OK
);
17792 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17794 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17796 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17798 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17799 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17800 digest
[2] = hex_to_uint (&input_buf
[16]);
17801 digest
[3] = hex_to_uint (&input_buf
[24]);
17802 digest
[4] = hex_to_uint (&input_buf
[32]);
17803 digest
[5] = hex_to_uint (&input_buf
[40]);
17804 digest
[6] = hex_to_uint (&input_buf
[48]);
17805 digest
[7] = hex_to_uint (&input_buf
[56]);
17807 digest
[0] = byte_swap_32 (digest
[0]);
17808 digest
[1] = byte_swap_32 (digest
[1]);
17809 digest
[2] = byte_swap_32 (digest
[2]);
17810 digest
[3] = byte_swap_32 (digest
[3]);
17811 digest
[4] = byte_swap_32 (digest
[4]);
17812 digest
[5] = byte_swap_32 (digest
[5]);
17813 digest
[6] = byte_swap_32 (digest
[6]);
17814 digest
[7] = byte_swap_32 (digest
[7]);
17816 return (PARSER_OK
);
17819 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17821 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17823 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17825 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17826 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17827 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17828 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17829 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17830 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17831 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17832 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17833 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17834 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17835 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17836 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17837 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17838 digest
[13] = hex_to_uint (&input_buf
[104]);
17839 digest
[14] = hex_to_uint (&input_buf
[112]);
17840 digest
[15] = hex_to_uint (&input_buf
[120]);
17842 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17843 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17844 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17845 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17846 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17847 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17848 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17849 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17850 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17851 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17852 digest
[10] = byte_swap_32 (digest
[10]);
17853 digest
[11] = byte_swap_32 (digest
[11]);
17854 digest
[12] = byte_swap_32 (digest
[12]);
17855 digest
[13] = byte_swap_32 (digest
[13]);
17856 digest
[14] = byte_swap_32 (digest
[14]);
17857 digest
[15] = byte_swap_32 (digest
[15]);
17859 return (PARSER_OK
);
17862 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17864 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17866 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17868 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17870 salt_t
*salt
= hash_buf
->salt
;
17872 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17880 char *iter_pos
= input_buf
+ 4;
17882 uint32_t iter
= atoi (iter_pos
);
17884 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17885 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17887 // first is *raw* salt
17889 char *salt_pos
= strchr (iter_pos
, ':');
17891 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17895 char *hash_pos
= strchr (salt_pos
, ':');
17897 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17899 uint32_t salt_len
= hash_pos
- salt_pos
;
17901 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17905 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17907 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17911 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17913 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17915 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17917 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17918 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17920 salt
->salt_len
= salt_len
;
17921 salt
->salt_iter
= iter
- 1;
17927 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17929 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17931 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17933 memcpy (digest
, tmp_buf
, 16);
17935 // add some stuff to normal salt to make sorted happy
17937 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17938 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17939 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17940 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17941 salt
->salt_buf
[4] = salt
->salt_iter
;
17943 return (PARSER_OK
);
17946 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17948 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17950 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17952 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17954 salt_t
*salt
= hash_buf
->salt
;
17956 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
17964 char *iter_pos
= input_buf
+ 5;
17966 uint32_t iter
= atoi (iter_pos
);
17968 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17969 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17971 // first is *raw* salt
17973 char *salt_pos
= strchr (iter_pos
, ':');
17975 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17979 char *hash_pos
= strchr (salt_pos
, ':');
17981 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17983 uint32_t salt_len
= hash_pos
- salt_pos
;
17985 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17989 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17991 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17995 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
17997 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18001 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18002 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18004 salt
->salt_len
= salt_len
;
18005 salt
->salt_iter
= iter
- 1;
18011 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18013 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18015 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18017 memcpy (digest
, tmp_buf
, 16);
18019 digest
[0] = byte_swap_32 (digest
[0]);
18020 digest
[1] = byte_swap_32 (digest
[1]);
18021 digest
[2] = byte_swap_32 (digest
[2]);
18022 digest
[3] = byte_swap_32 (digest
[3]);
18024 // add some stuff to normal salt to make sorted happy
18026 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18027 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18028 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18029 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18030 salt
->salt_buf
[4] = salt
->salt_iter
;
18032 return (PARSER_OK
);
18035 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18037 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18039 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18041 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18043 salt_t
*salt
= hash_buf
->salt
;
18045 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18053 char *iter_pos
= input_buf
+ 7;
18055 uint32_t iter
= atoi (iter_pos
);
18057 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18058 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18060 // first is *raw* salt
18062 char *salt_pos
= strchr (iter_pos
, ':');
18064 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18068 char *hash_pos
= strchr (salt_pos
, ':');
18070 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18072 uint32_t salt_len
= hash_pos
- salt_pos
;
18074 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18078 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18080 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18084 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18086 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18088 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18090 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18091 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18093 salt
->salt_len
= salt_len
;
18094 salt
->salt_iter
= iter
- 1;
18100 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18102 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18104 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18106 memcpy (digest
, tmp_buf
, 64);
18108 digest
[0] = byte_swap_64 (digest
[0]);
18109 digest
[1] = byte_swap_64 (digest
[1]);
18110 digest
[2] = byte_swap_64 (digest
[2]);
18111 digest
[3] = byte_swap_64 (digest
[3]);
18112 digest
[4] = byte_swap_64 (digest
[4]);
18113 digest
[5] = byte_swap_64 (digest
[5]);
18114 digest
[6] = byte_swap_64 (digest
[6]);
18115 digest
[7] = byte_swap_64 (digest
[7]);
18117 // add some stuff to normal salt to make sorted happy
18119 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18120 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18121 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18122 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18123 salt
->salt_buf
[4] = salt
->salt_iter
;
18125 return (PARSER_OK
);
18128 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18130 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18132 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18134 uint
*digest
= (uint
*) hash_buf
->digest
;
18136 salt_t
*salt
= hash_buf
->salt
;
18142 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18144 char *hash_pos
= strchr (salt_pos
, '$');
18146 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18148 uint32_t salt_len
= hash_pos
- salt_pos
;
18150 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18154 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18156 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18160 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18161 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18179 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18180 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18182 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18183 salt
->salt_len
= 8;
18185 return (PARSER_OK
);
18188 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18190 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18192 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18194 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18196 if (c19
& 3) return (PARSER_HASH_VALUE
);
18198 salt_t
*salt
= hash_buf
->salt
;
18200 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18204 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18205 | itoa64_to_int (input_buf
[2]) << 6
18206 | itoa64_to_int (input_buf
[3]) << 12
18207 | itoa64_to_int (input_buf
[4]) << 18;
18211 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18212 | itoa64_to_int (input_buf
[6]) << 6
18213 | itoa64_to_int (input_buf
[7]) << 12
18214 | itoa64_to_int (input_buf
[8]) << 18;
18216 salt
->salt_len
= 4;
18220 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18222 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18224 memcpy (digest
, tmp_buf
, 8);
18228 IP (digest
[0], digest
[1], tt
);
18230 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18231 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18235 return (PARSER_OK
);
18238 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18240 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18242 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18244 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18246 salt_t
*salt
= hash_buf
->salt
;
18252 char *type_pos
= input_buf
+ 6 + 1;
18254 char *salt_pos
= strchr (type_pos
, '*');
18256 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18258 uint32_t type_len
= salt_pos
- type_pos
;
18260 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18264 char *crypted_pos
= strchr (salt_pos
, '*');
18266 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18268 uint32_t salt_len
= crypted_pos
- salt_pos
;
18270 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18274 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18276 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18282 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18283 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18285 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18286 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18288 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18289 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18290 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18291 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18293 salt
->salt_len
= 24;
18294 salt
->salt_iter
= ROUNDS_RAR3
;
18296 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18297 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18299 digest
[0] = 0xc43d7b00;
18300 digest
[1] = 0x40070000;
18304 return (PARSER_OK
);
18307 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18309 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18311 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18313 salt_t
*salt
= hash_buf
->salt
;
18315 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18316 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18317 digest
[2] = hex_to_uint (&input_buf
[16]);
18318 digest
[3] = hex_to_uint (&input_buf
[24]);
18319 digest
[4] = hex_to_uint (&input_buf
[32]);
18320 digest
[5] = hex_to_uint (&input_buf
[40]);
18321 digest
[6] = hex_to_uint (&input_buf
[48]);
18322 digest
[7] = hex_to_uint (&input_buf
[56]);
18324 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18326 uint salt_len
= input_len
- 64 - 1;
18328 char *salt_buf
= input_buf
+ 64 + 1;
18330 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18332 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18334 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18336 salt
->salt_len
= salt_len
;
18339 * we can precompute the first sha256 transform
18344 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18345 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18346 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18347 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18348 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18349 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18350 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18351 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18352 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18353 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18354 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18355 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18356 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18357 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18358 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18359 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18363 pc256
[0] = SHA256M_A
;
18364 pc256
[1] = SHA256M_B
;
18365 pc256
[2] = SHA256M_C
;
18366 pc256
[3] = SHA256M_D
;
18367 pc256
[4] = SHA256M_E
;
18368 pc256
[5] = SHA256M_F
;
18369 pc256
[6] = SHA256M_G
;
18370 pc256
[7] = SHA256M_H
;
18372 sha256_64 (w
, pc256
);
18374 salt
->salt_buf_pc
[0] = pc256
[0];
18375 salt
->salt_buf_pc
[1] = pc256
[1];
18376 salt
->salt_buf_pc
[2] = pc256
[2];
18377 salt
->salt_buf_pc
[3] = pc256
[3];
18378 salt
->salt_buf_pc
[4] = pc256
[4];
18379 salt
->salt_buf_pc
[5] = pc256
[5];
18380 salt
->salt_buf_pc
[6] = pc256
[6];
18381 salt
->salt_buf_pc
[7] = pc256
[7];
18383 digest
[0] -= pc256
[0];
18384 digest
[1] -= pc256
[1];
18385 digest
[2] -= pc256
[2];
18386 digest
[3] -= pc256
[3];
18387 digest
[4] -= pc256
[4];
18388 digest
[5] -= pc256
[5];
18389 digest
[6] -= pc256
[6];
18390 digest
[7] -= pc256
[7];
18392 return (PARSER_OK
);
18395 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18397 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18399 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18401 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18403 salt_t
*salt
= hash_buf
->salt
;
18409 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18411 char *data_buf_pos
= strchr (data_len_pos
, '$');
18413 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18415 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18417 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18418 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18422 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18424 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18426 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18428 uint32_t data_len
= atoi (data_len_pos
);
18430 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18436 char *salt_pos
= data_buf_pos
;
18438 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18439 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18440 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18441 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18443 // this is actually the CT, which is also the hash later (if matched)
18445 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18446 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18447 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18448 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18450 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18452 salt
->salt_iter
= 10 - 1;
18458 digest
[0] = salt
->salt_buf
[4];
18459 digest
[1] = salt
->salt_buf
[5];
18460 digest
[2] = salt
->salt_buf
[6];
18461 digest
[3] = salt
->salt_buf
[7];
18463 return (PARSER_OK
);
18466 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18468 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18470 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18472 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18474 salt_t
*salt
= hash_buf
->salt
;
18480 char *salt_pos
= input_buf
+ 11 + 1;
18482 char *iter_pos
= strchr (salt_pos
, ',');
18484 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18486 uint32_t salt_len
= iter_pos
- salt_pos
;
18488 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18492 char *hash_pos
= strchr (iter_pos
, ',');
18494 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18496 uint32_t iter_len
= hash_pos
- iter_pos
;
18498 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18502 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18504 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18510 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18511 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18512 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18513 salt
->salt_buf
[3] = 0x00018000;
18515 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18516 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18517 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18518 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18520 salt
->salt_len
= salt_len
/ 2;
18522 salt
->salt_iter
= atoi (iter_pos
) - 1;
18528 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18529 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18530 digest
[2] = hex_to_uint (&hash_pos
[16]);
18531 digest
[3] = hex_to_uint (&hash_pos
[24]);
18532 digest
[4] = hex_to_uint (&hash_pos
[32]);
18533 digest
[5] = hex_to_uint (&hash_pos
[40]);
18534 digest
[6] = hex_to_uint (&hash_pos
[48]);
18535 digest
[7] = hex_to_uint (&hash_pos
[56]);
18537 return (PARSER_OK
);
18541 * parallel running threads
18546 BOOL WINAPI
sigHandler_default (DWORD sig
)
18550 case CTRL_CLOSE_EVENT
:
18553 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18554 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18555 * function otherwise it is to late (e.g. after returning from this function)
18560 SetConsoleCtrlHandler (NULL
, TRUE
);
18567 case CTRL_LOGOFF_EVENT
:
18568 case CTRL_SHUTDOWN_EVENT
:
18572 SetConsoleCtrlHandler (NULL
, TRUE
);
18580 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18584 case CTRL_CLOSE_EVENT
:
18588 SetConsoleCtrlHandler (NULL
, TRUE
);
18595 case CTRL_LOGOFF_EVENT
:
18596 case CTRL_SHUTDOWN_EVENT
:
18600 SetConsoleCtrlHandler (NULL
, TRUE
);
18608 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18610 if (callback
== NULL
)
18612 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18616 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18622 void sigHandler_default (int sig
)
18626 signal (sig
, NULL
);
18629 void sigHandler_benchmark (int sig
)
18633 signal (sig
, NULL
);
18636 void hc_signal (void (callback
) (int))
18638 if (callback
== NULL
) callback
= SIG_DFL
;
18640 signal (SIGINT
, callback
);
18641 signal (SIGTERM
, callback
);
18642 signal (SIGABRT
, callback
);
18647 void status_display ();
18649 void *thread_keypress (void *p
)
18651 int benchmark
= *((int *) p
);
18653 uint quiet
= data
.quiet
;
18657 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18659 int ch
= tty_getchar();
18661 if (ch
== -1) break;
18663 if (ch
== 0) continue;
18669 hc_thread_mutex_lock (mux_display
);
18684 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18685 if (quiet
== 0) fflush (stdout
);
18697 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18698 if (quiet
== 0) fflush (stdout
);
18710 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18711 if (quiet
== 0) fflush (stdout
);
18723 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18724 if (quiet
== 0) fflush (stdout
);
18732 if (benchmark
== 1) break;
18734 stop_at_checkpoint ();
18738 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18739 if (quiet
== 0) fflush (stdout
);
18747 if (benchmark
== 1)
18759 hc_thread_mutex_unlock (mux_display
);
18771 bool class_num (char c
)
18773 return ((c
>= '0') && (c
<= '9'));
18776 bool class_lower (char c
)
18778 return ((c
>= 'a') && (c
<= 'z'));
18781 bool class_upper (char c
)
18783 return ((c
>= 'A') && (c
<= 'Z'));
18786 bool class_alpha (char c
)
18788 return (class_lower (c
) || class_upper (c
));
18791 char conv_ctoi (char c
)
18797 else if (class_upper (c
))
18799 return c
- 'A' + (char) 10;
18802 return (char) (-1);
18805 char conv_itoc (char c
)
18813 return c
+ 'A' - (char) 10;
18816 return (char) (-1);
18823 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18824 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18825 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18826 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18827 #define MAX_GPU_RULES 14
18828 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18829 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18830 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18832 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18833 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18834 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18835 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18837 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18842 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18844 switch (rule_buf
[rule_pos
])
18850 case RULE_OP_MANGLE_NOOP
:
18851 SET_NAME (rule
, rule_buf
[rule_pos
]);
18854 case RULE_OP_MANGLE_LREST
:
18855 SET_NAME (rule
, rule_buf
[rule_pos
]);
18858 case RULE_OP_MANGLE_UREST
:
18859 SET_NAME (rule
, rule_buf
[rule_pos
]);
18862 case RULE_OP_MANGLE_LREST_UFIRST
:
18863 SET_NAME (rule
, rule_buf
[rule_pos
]);
18866 case RULE_OP_MANGLE_UREST_LFIRST
:
18867 SET_NAME (rule
, rule_buf
[rule_pos
]);
18870 case RULE_OP_MANGLE_TREST
:
18871 SET_NAME (rule
, rule_buf
[rule_pos
]);
18874 case RULE_OP_MANGLE_TOGGLE_AT
:
18875 SET_NAME (rule
, rule_buf
[rule_pos
]);
18876 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18879 case RULE_OP_MANGLE_REVERSE
:
18880 SET_NAME (rule
, rule_buf
[rule_pos
]);
18883 case RULE_OP_MANGLE_DUPEWORD
:
18884 SET_NAME (rule
, rule_buf
[rule_pos
]);
18887 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18888 SET_NAME (rule
, rule_buf
[rule_pos
]);
18889 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18892 case RULE_OP_MANGLE_REFLECT
:
18893 SET_NAME (rule
, rule_buf
[rule_pos
]);
18896 case RULE_OP_MANGLE_ROTATE_LEFT
:
18897 SET_NAME (rule
, rule_buf
[rule_pos
]);
18900 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18901 SET_NAME (rule
, rule_buf
[rule_pos
]);
18904 case RULE_OP_MANGLE_APPEND
:
18905 SET_NAME (rule
, rule_buf
[rule_pos
]);
18906 SET_P0 (rule
, rule_buf
[rule_pos
]);
18909 case RULE_OP_MANGLE_PREPEND
:
18910 SET_NAME (rule
, rule_buf
[rule_pos
]);
18911 SET_P0 (rule
, rule_buf
[rule_pos
]);
18914 case RULE_OP_MANGLE_DELETE_FIRST
:
18915 SET_NAME (rule
, rule_buf
[rule_pos
]);
18918 case RULE_OP_MANGLE_DELETE_LAST
:
18919 SET_NAME (rule
, rule_buf
[rule_pos
]);
18922 case RULE_OP_MANGLE_DELETE_AT
:
18923 SET_NAME (rule
, rule_buf
[rule_pos
]);
18924 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18927 case RULE_OP_MANGLE_EXTRACT
:
18928 SET_NAME (rule
, rule_buf
[rule_pos
]);
18929 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18930 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18933 case RULE_OP_MANGLE_OMIT
:
18934 SET_NAME (rule
, rule_buf
[rule_pos
]);
18935 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18936 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18939 case RULE_OP_MANGLE_INSERT
:
18940 SET_NAME (rule
, rule_buf
[rule_pos
]);
18941 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18942 SET_P1 (rule
, rule_buf
[rule_pos
]);
18945 case RULE_OP_MANGLE_OVERSTRIKE
:
18946 SET_NAME (rule
, rule_buf
[rule_pos
]);
18947 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18948 SET_P1 (rule
, rule_buf
[rule_pos
]);
18951 case RULE_OP_MANGLE_TRUNCATE_AT
:
18952 SET_NAME (rule
, rule_buf
[rule_pos
]);
18953 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18956 case RULE_OP_MANGLE_REPLACE
:
18957 SET_NAME (rule
, rule_buf
[rule_pos
]);
18958 SET_P0 (rule
, rule_buf
[rule_pos
]);
18959 SET_P1 (rule
, rule_buf
[rule_pos
]);
18962 case RULE_OP_MANGLE_PURGECHAR
:
18966 case RULE_OP_MANGLE_TOGGLECASE_REC
:
18970 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
18971 SET_NAME (rule
, rule_buf
[rule_pos
]);
18972 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18975 case RULE_OP_MANGLE_DUPECHAR_LAST
:
18976 SET_NAME (rule
, rule_buf
[rule_pos
]);
18977 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18980 case RULE_OP_MANGLE_DUPECHAR_ALL
:
18981 SET_NAME (rule
, rule_buf
[rule_pos
]);
18984 case RULE_OP_MANGLE_SWITCH_FIRST
:
18985 SET_NAME (rule
, rule_buf
[rule_pos
]);
18988 case RULE_OP_MANGLE_SWITCH_LAST
:
18989 SET_NAME (rule
, rule_buf
[rule_pos
]);
18992 case RULE_OP_MANGLE_SWITCH_AT
:
18993 SET_NAME (rule
, rule_buf
[rule_pos
]);
18994 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18995 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18998 case RULE_OP_MANGLE_CHR_SHIFTL
:
18999 SET_NAME (rule
, rule_buf
[rule_pos
]);
19000 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19003 case RULE_OP_MANGLE_CHR_SHIFTR
:
19004 SET_NAME (rule
, rule_buf
[rule_pos
]);
19005 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19008 case RULE_OP_MANGLE_CHR_INCR
:
19009 SET_NAME (rule
, rule_buf
[rule_pos
]);
19010 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19013 case RULE_OP_MANGLE_CHR_DECR
:
19014 SET_NAME (rule
, rule_buf
[rule_pos
]);
19015 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19018 case RULE_OP_MANGLE_REPLACE_NP1
:
19019 SET_NAME (rule
, rule_buf
[rule_pos
]);
19020 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19023 case RULE_OP_MANGLE_REPLACE_NM1
:
19024 SET_NAME (rule
, rule_buf
[rule_pos
]);
19025 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19028 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19029 SET_NAME (rule
, rule_buf
[rule_pos
]);
19030 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19033 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19034 SET_NAME (rule
, rule_buf
[rule_pos
]);
19035 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19038 case RULE_OP_MANGLE_TITLE
:
19039 SET_NAME (rule
, rule_buf
[rule_pos
]);
19048 if (rule_pos
< rule_len
) return (-1);
19053 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19057 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19061 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19065 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19069 case RULE_OP_MANGLE_NOOP
:
19070 rule_buf
[rule_pos
] = rule_cmd
;
19073 case RULE_OP_MANGLE_LREST
:
19074 rule_buf
[rule_pos
] = rule_cmd
;
19077 case RULE_OP_MANGLE_UREST
:
19078 rule_buf
[rule_pos
] = rule_cmd
;
19081 case RULE_OP_MANGLE_LREST_UFIRST
:
19082 rule_buf
[rule_pos
] = rule_cmd
;
19085 case RULE_OP_MANGLE_UREST_LFIRST
:
19086 rule_buf
[rule_pos
] = rule_cmd
;
19089 case RULE_OP_MANGLE_TREST
:
19090 rule_buf
[rule_pos
] = rule_cmd
;
19093 case RULE_OP_MANGLE_TOGGLE_AT
:
19094 rule_buf
[rule_pos
] = rule_cmd
;
19095 GET_P0_CONV (rule
);
19098 case RULE_OP_MANGLE_REVERSE
:
19099 rule_buf
[rule_pos
] = rule_cmd
;
19102 case RULE_OP_MANGLE_DUPEWORD
:
19103 rule_buf
[rule_pos
] = rule_cmd
;
19106 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19107 rule_buf
[rule_pos
] = rule_cmd
;
19108 GET_P0_CONV (rule
);
19111 case RULE_OP_MANGLE_REFLECT
:
19112 rule_buf
[rule_pos
] = rule_cmd
;
19115 case RULE_OP_MANGLE_ROTATE_LEFT
:
19116 rule_buf
[rule_pos
] = rule_cmd
;
19119 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19120 rule_buf
[rule_pos
] = rule_cmd
;
19123 case RULE_OP_MANGLE_APPEND
:
19124 rule_buf
[rule_pos
] = rule_cmd
;
19128 case RULE_OP_MANGLE_PREPEND
:
19129 rule_buf
[rule_pos
] = rule_cmd
;
19133 case RULE_OP_MANGLE_DELETE_FIRST
:
19134 rule_buf
[rule_pos
] = rule_cmd
;
19137 case RULE_OP_MANGLE_DELETE_LAST
:
19138 rule_buf
[rule_pos
] = rule_cmd
;
19141 case RULE_OP_MANGLE_DELETE_AT
:
19142 rule_buf
[rule_pos
] = rule_cmd
;
19143 GET_P0_CONV (rule
);
19146 case RULE_OP_MANGLE_EXTRACT
:
19147 rule_buf
[rule_pos
] = rule_cmd
;
19148 GET_P0_CONV (rule
);
19149 GET_P1_CONV (rule
);
19152 case RULE_OP_MANGLE_OMIT
:
19153 rule_buf
[rule_pos
] = rule_cmd
;
19154 GET_P0_CONV (rule
);
19155 GET_P1_CONV (rule
);
19158 case RULE_OP_MANGLE_INSERT
:
19159 rule_buf
[rule_pos
] = rule_cmd
;
19160 GET_P0_CONV (rule
);
19164 case RULE_OP_MANGLE_OVERSTRIKE
:
19165 rule_buf
[rule_pos
] = rule_cmd
;
19166 GET_P0_CONV (rule
);
19170 case RULE_OP_MANGLE_TRUNCATE_AT
:
19171 rule_buf
[rule_pos
] = rule_cmd
;
19172 GET_P0_CONV (rule
);
19175 case RULE_OP_MANGLE_REPLACE
:
19176 rule_buf
[rule_pos
] = rule_cmd
;
19181 case RULE_OP_MANGLE_PURGECHAR
:
19185 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19189 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19190 rule_buf
[rule_pos
] = rule_cmd
;
19191 GET_P0_CONV (rule
);
19194 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19195 rule_buf
[rule_pos
] = rule_cmd
;
19196 GET_P0_CONV (rule
);
19199 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19200 rule_buf
[rule_pos
] = rule_cmd
;
19203 case RULE_OP_MANGLE_SWITCH_FIRST
:
19204 rule_buf
[rule_pos
] = rule_cmd
;
19207 case RULE_OP_MANGLE_SWITCH_LAST
:
19208 rule_buf
[rule_pos
] = rule_cmd
;
19211 case RULE_OP_MANGLE_SWITCH_AT
:
19212 rule_buf
[rule_pos
] = rule_cmd
;
19213 GET_P0_CONV (rule
);
19214 GET_P1_CONV (rule
);
19217 case RULE_OP_MANGLE_CHR_SHIFTL
:
19218 rule_buf
[rule_pos
] = rule_cmd
;
19219 GET_P0_CONV (rule
);
19222 case RULE_OP_MANGLE_CHR_SHIFTR
:
19223 rule_buf
[rule_pos
] = rule_cmd
;
19224 GET_P0_CONV (rule
);
19227 case RULE_OP_MANGLE_CHR_INCR
:
19228 rule_buf
[rule_pos
] = rule_cmd
;
19229 GET_P0_CONV (rule
);
19232 case RULE_OP_MANGLE_CHR_DECR
:
19233 rule_buf
[rule_pos
] = rule_cmd
;
19234 GET_P0_CONV (rule
);
19237 case RULE_OP_MANGLE_REPLACE_NP1
:
19238 rule_buf
[rule_pos
] = rule_cmd
;
19239 GET_P0_CONV (rule
);
19242 case RULE_OP_MANGLE_REPLACE_NM1
:
19243 rule_buf
[rule_pos
] = rule_cmd
;
19244 GET_P0_CONV (rule
);
19247 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19248 rule_buf
[rule_pos
] = rule_cmd
;
19249 GET_P0_CONV (rule
);
19252 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19253 rule_buf
[rule_pos
] = rule_cmd
;
19254 GET_P0_CONV (rule
);
19257 case RULE_OP_MANGLE_TITLE
:
19258 rule_buf
[rule_pos
] = rule_cmd
;
19262 return rule_pos
- 1;
19280 * CPU rules : this is from hashcat sources, cpu based rules
19283 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19284 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19286 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19287 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19288 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19290 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19291 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19292 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19294 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19298 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19303 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19307 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19312 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19316 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19321 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19326 for (l
= 0; l
< arr_len
; l
++)
19328 r
= arr_len
- 1 - l
;
19332 MANGLE_SWITCH (arr
, l
, r
);
19338 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19340 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19342 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19344 return (arr_len
* 2);
19347 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19349 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19351 int orig_len
= arr_len
;
19355 for (i
= 0; i
< times
; i
++)
19357 memcpy (&arr
[arr_len
], arr
, orig_len
);
19359 arr_len
+= orig_len
;
19365 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19367 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19369 mangle_double (arr
, arr_len
);
19371 mangle_reverse (arr
+ arr_len
, arr_len
);
19373 return (arr_len
* 2);
19376 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19381 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19383 MANGLE_SWITCH (arr
, l
, r
);
19389 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19394 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19396 MANGLE_SWITCH (arr
, l
, r
);
19402 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19404 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19408 return (arr_len
+ 1);
19411 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19413 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19417 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19419 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19424 return (arr_len
+ 1);
19427 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19429 if (upos
>= arr_len
) return (arr_len
);
19433 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19435 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19438 return (arr_len
- 1);
19441 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19443 if (upos
>= arr_len
) return (arr_len
);
19445 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19449 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19451 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19457 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19459 if (upos
>= arr_len
) return (arr_len
);
19461 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19465 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19467 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19470 return (arr_len
- ulen
);
19473 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19475 if (upos
>= arr_len
) return (arr_len
);
19477 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19481 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19483 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19488 return (arr_len
+ 1);
19491 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
)
19493 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19495 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19497 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19499 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19501 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19503 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19505 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19507 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19509 return (arr_len
+ arr2_cpy
);
19512 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19514 if (upos
>= arr_len
) return (arr_len
);
19521 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19523 if (upos
>= arr_len
) return (arr_len
);
19525 memset (arr
+ upos
, 0, arr_len
- upos
);
19530 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19534 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19536 if (arr
[arr_pos
] != oldc
) continue;
19538 arr
[arr_pos
] = newc
;
19544 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19550 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19552 if (arr
[arr_pos
] == c
) continue;
19554 arr
[ret_len
] = arr
[arr_pos
];
19562 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19564 if (ulen
> arr_len
) return (arr_len
);
19566 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19570 memcpy (cs
, arr
, ulen
);
19574 for (i
= 0; i
< ulen
; i
++)
19578 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19584 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19586 if (ulen
> arr_len
) return (arr_len
);
19588 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19590 int upos
= arr_len
- ulen
;
19594 for (i
= 0; i
< ulen
; i
++)
19596 char c
= arr
[upos
+ i
];
19598 arr_len
= mangle_append (arr
, arr_len
, c
);
19604 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19606 if ( arr_len
== 0) return (arr_len
);
19607 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19609 char c
= arr
[upos
];
19613 for (i
= 0; i
< ulen
; i
++)
19615 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19621 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19623 if ( arr_len
== 0) return (arr_len
);
19624 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19628 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19630 int new_pos
= arr_pos
* 2;
19632 arr
[new_pos
] = arr
[arr_pos
];
19634 arr
[new_pos
+ 1] = arr
[arr_pos
];
19637 return (arr_len
* 2);
19640 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19642 if (upos
>= arr_len
) return (arr_len
);
19643 if (upos2
>= arr_len
) return (arr_len
);
19645 MANGLE_SWITCH (arr
, upos
, upos2
);
19650 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19652 MANGLE_SWITCH (arr
, upos
, upos2
);
19657 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19659 if (upos
>= arr_len
) return (arr_len
);
19666 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19668 if (upos
>= arr_len
) return (arr_len
);
19675 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19677 if (upos
>= arr_len
) return (arr_len
);
19684 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19686 if (upos
>= arr_len
) return (arr_len
);
19693 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19695 int upper_next
= 1;
19699 for (pos
= 0; pos
< arr_len
; pos
++)
19701 if (arr
[pos
] == ' ')
19712 MANGLE_UPPER_AT (arr
, pos
);
19716 MANGLE_LOWER_AT (arr
, pos
);
19723 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19725 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19729 uint32_t rule_pos
= 0;
19731 for (j
= 0; j
< rp_gen_num
; j
++)
19738 switch ((char) get_random_num (0, 9))
19741 r
= get_random_num (0, sizeof (grp_op_nop
));
19742 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19746 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19747 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19748 p1
= get_random_num (0, sizeof (grp_pos
));
19749 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19753 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19754 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19755 p1
= get_random_num (1, 6);
19756 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19760 r
= get_random_num (0, sizeof (grp_op_chr
));
19761 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19762 p1
= get_random_num (0x20, 0x7e);
19763 rule_buf
[rule_pos
++] = (char) p1
;
19767 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19768 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19769 p1
= get_random_num (0x20, 0x7e);
19770 rule_buf
[rule_pos
++] = (char) p1
;
19771 p2
= get_random_num (0x20, 0x7e);
19773 p2
= get_random_num (0x20, 0x7e);
19774 rule_buf
[rule_pos
++] = (char) p2
;
19778 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19779 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19780 p1
= get_random_num (0, sizeof (grp_pos
));
19781 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19782 p2
= get_random_num (0x20, 0x7e);
19783 rule_buf
[rule_pos
++] = (char) p2
;
19787 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19788 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19789 p1
= get_random_num (0, sizeof (grp_pos
));
19790 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19791 p2
= get_random_num (0, sizeof (grp_pos
));
19793 p2
= get_random_num (0, sizeof (grp_pos
));
19794 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19798 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19799 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19800 p1
= get_random_num (0, sizeof (grp_pos
));
19801 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19802 p2
= get_random_num (1, sizeof (grp_pos
));
19804 p2
= get_random_num (1, sizeof (grp_pos
));
19805 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19809 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19810 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19811 p1
= get_random_num (0, sizeof (grp_pos
));
19812 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19813 p2
= get_random_num (1, sizeof (grp_pos
));
19814 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19815 p3
= get_random_num (0, sizeof (grp_pos
));
19816 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19824 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19826 char mem
[BLOCK_SIZE
];
19828 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19830 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19832 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19834 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19836 int out_len
= in_len
;
19837 int mem_len
= in_len
;
19839 memcpy (out
, in
, out_len
);
19843 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19845 int upos
; int upos2
;
19848 switch (rule
[rule_pos
])
19853 case RULE_OP_MANGLE_NOOP
:
19856 case RULE_OP_MANGLE_LREST
:
19857 out_len
= mangle_lrest (out
, out_len
);
19860 case RULE_OP_MANGLE_UREST
:
19861 out_len
= mangle_urest (out
, out_len
);
19864 case RULE_OP_MANGLE_LREST_UFIRST
:
19865 out_len
= mangle_lrest (out
, out_len
);
19866 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19869 case RULE_OP_MANGLE_UREST_LFIRST
:
19870 out_len
= mangle_urest (out
, out_len
);
19871 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19874 case RULE_OP_MANGLE_TREST
:
19875 out_len
= mangle_trest (out
, out_len
);
19878 case RULE_OP_MANGLE_TOGGLE_AT
:
19879 NEXT_RULEPOS (rule_pos
);
19880 NEXT_RPTOI (rule
, rule_pos
, upos
);
19881 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19884 case RULE_OP_MANGLE_REVERSE
:
19885 out_len
= mangle_reverse (out
, out_len
);
19888 case RULE_OP_MANGLE_DUPEWORD
:
19889 out_len
= mangle_double (out
, out_len
);
19892 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19893 NEXT_RULEPOS (rule_pos
);
19894 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19895 out_len
= mangle_double_times (out
, out_len
, ulen
);
19898 case RULE_OP_MANGLE_REFLECT
:
19899 out_len
= mangle_reflect (out
, out_len
);
19902 case RULE_OP_MANGLE_ROTATE_LEFT
:
19903 mangle_rotate_left (out
, out_len
);
19906 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19907 mangle_rotate_right (out
, out_len
);
19910 case RULE_OP_MANGLE_APPEND
:
19911 NEXT_RULEPOS (rule_pos
);
19912 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19915 case RULE_OP_MANGLE_PREPEND
:
19916 NEXT_RULEPOS (rule_pos
);
19917 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19920 case RULE_OP_MANGLE_DELETE_FIRST
:
19921 out_len
= mangle_delete_at (out
, out_len
, 0);
19924 case RULE_OP_MANGLE_DELETE_LAST
:
19925 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19928 case RULE_OP_MANGLE_DELETE_AT
:
19929 NEXT_RULEPOS (rule_pos
);
19930 NEXT_RPTOI (rule
, rule_pos
, upos
);
19931 out_len
= mangle_delete_at (out
, out_len
, upos
);
19934 case RULE_OP_MANGLE_EXTRACT
:
19935 NEXT_RULEPOS (rule_pos
);
19936 NEXT_RPTOI (rule
, rule_pos
, upos
);
19937 NEXT_RULEPOS (rule_pos
);
19938 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19939 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19942 case RULE_OP_MANGLE_OMIT
:
19943 NEXT_RULEPOS (rule_pos
);
19944 NEXT_RPTOI (rule
, rule_pos
, upos
);
19945 NEXT_RULEPOS (rule_pos
);
19946 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19947 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19950 case RULE_OP_MANGLE_INSERT
:
19951 NEXT_RULEPOS (rule_pos
);
19952 NEXT_RPTOI (rule
, rule_pos
, upos
);
19953 NEXT_RULEPOS (rule_pos
);
19954 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19957 case RULE_OP_MANGLE_OVERSTRIKE
:
19958 NEXT_RULEPOS (rule_pos
);
19959 NEXT_RPTOI (rule
, rule_pos
, upos
);
19960 NEXT_RULEPOS (rule_pos
);
19961 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
19964 case RULE_OP_MANGLE_TRUNCATE_AT
:
19965 NEXT_RULEPOS (rule_pos
);
19966 NEXT_RPTOI (rule
, rule_pos
, upos
);
19967 out_len
= mangle_truncate_at (out
, out_len
, upos
);
19970 case RULE_OP_MANGLE_REPLACE
:
19971 NEXT_RULEPOS (rule_pos
);
19972 NEXT_RULEPOS (rule_pos
);
19973 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
19976 case RULE_OP_MANGLE_PURGECHAR
:
19977 NEXT_RULEPOS (rule_pos
);
19978 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
19981 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19985 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19986 NEXT_RULEPOS (rule_pos
);
19987 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19988 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
19991 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19992 NEXT_RULEPOS (rule_pos
);
19993 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19994 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
19997 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19998 out_len
= mangle_dupechar (out
, out_len
);
20001 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20002 NEXT_RULEPOS (rule_pos
);
20003 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20004 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20007 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20008 NEXT_RULEPOS (rule_pos
);
20009 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20010 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20013 case RULE_OP_MANGLE_SWITCH_FIRST
:
20014 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20017 case RULE_OP_MANGLE_SWITCH_LAST
:
20018 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20021 case RULE_OP_MANGLE_SWITCH_AT
:
20022 NEXT_RULEPOS (rule_pos
);
20023 NEXT_RPTOI (rule
, rule_pos
, upos
);
20024 NEXT_RULEPOS (rule_pos
);
20025 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20026 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20029 case RULE_OP_MANGLE_CHR_SHIFTL
:
20030 NEXT_RULEPOS (rule_pos
);
20031 NEXT_RPTOI (rule
, rule_pos
, upos
);
20032 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20035 case RULE_OP_MANGLE_CHR_SHIFTR
:
20036 NEXT_RULEPOS (rule_pos
);
20037 NEXT_RPTOI (rule
, rule_pos
, upos
);
20038 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20041 case RULE_OP_MANGLE_CHR_INCR
:
20042 NEXT_RULEPOS (rule_pos
);
20043 NEXT_RPTOI (rule
, rule_pos
, upos
);
20044 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20047 case RULE_OP_MANGLE_CHR_DECR
:
20048 NEXT_RULEPOS (rule_pos
);
20049 NEXT_RPTOI (rule
, rule_pos
, upos
);
20050 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20053 case RULE_OP_MANGLE_REPLACE_NP1
:
20054 NEXT_RULEPOS (rule_pos
);
20055 NEXT_RPTOI (rule
, rule_pos
, upos
);
20056 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20059 case RULE_OP_MANGLE_REPLACE_NM1
:
20060 NEXT_RULEPOS (rule_pos
);
20061 NEXT_RPTOI (rule
, rule_pos
, upos
);
20062 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20065 case RULE_OP_MANGLE_TITLE
:
20066 out_len
= mangle_title (out
, out_len
);
20069 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20070 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20071 NEXT_RULEPOS (rule_pos
);
20072 NEXT_RPTOI (rule
, rule_pos
, upos
);
20073 NEXT_RULEPOS (rule_pos
);
20074 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20075 NEXT_RULEPOS (rule_pos
);
20076 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20077 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20080 case RULE_OP_MANGLE_APPEND_MEMORY
:
20081 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20082 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20083 memcpy (out
+ out_len
, mem
, mem_len
);
20084 out_len
+= mem_len
;
20087 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20088 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20089 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20090 memcpy (mem
+ mem_len
, out
, out_len
);
20091 out_len
+= mem_len
;
20092 memcpy (out
, mem
, out_len
);
20095 case RULE_OP_MEMORIZE_WORD
:
20096 memcpy (mem
, out
, out_len
);
20100 case RULE_OP_REJECT_LESS
:
20101 NEXT_RULEPOS (rule_pos
);
20102 NEXT_RPTOI (rule
, rule_pos
, upos
);
20103 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20106 case RULE_OP_REJECT_GREATER
:
20107 NEXT_RULEPOS (rule_pos
);
20108 NEXT_RPTOI (rule
, rule_pos
, upos
);
20109 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20112 case RULE_OP_REJECT_CONTAIN
:
20113 NEXT_RULEPOS (rule_pos
);
20114 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20117 case RULE_OP_REJECT_NOT_CONTAIN
:
20118 NEXT_RULEPOS (rule_pos
);
20119 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20122 case RULE_OP_REJECT_EQUAL_FIRST
:
20123 NEXT_RULEPOS (rule_pos
);
20124 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20127 case RULE_OP_REJECT_EQUAL_LAST
:
20128 NEXT_RULEPOS (rule_pos
);
20129 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20132 case RULE_OP_REJECT_EQUAL_AT
:
20133 NEXT_RULEPOS (rule_pos
);
20134 NEXT_RPTOI (rule
, rule_pos
, upos
);
20135 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20136 NEXT_RULEPOS (rule_pos
);
20137 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20140 case RULE_OP_REJECT_CONTAINS
:
20141 NEXT_RULEPOS (rule_pos
);
20142 NEXT_RPTOI (rule
, rule_pos
, upos
);
20143 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20144 NEXT_RULEPOS (rule_pos
);
20145 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20146 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20149 case RULE_OP_REJECT_MEMORY
:
20150 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20154 return (RULE_RC_SYNTAX_ERROR
);
20159 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);