2 * Author......: Jens Steube <jens.steube@gmail.com>
9 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
10 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
16 #define GET_ACCEL(x) GPU_ACCEL_AMD_ ## x
17 #define GET_LOOPS(x) GPU_LOOPS_AMD_ ## x
23 uint32_t rotl32 (const uint32_t a
, const uint n
)
25 return ((a
<< n
) | (a
>> (32 - n
)));
28 uint32_t rotr32 (const uint32_t a
, const uint n
)
30 return ((a
>> n
) | (a
<< (32 - n
)));
33 uint64_t rotl64 (const uint64_t a
, const uint n
)
35 return ((a
<< n
) | (a
>> (64 - n
)));
38 uint64_t rotr64 (const uint64_t a
, const uint n
)
40 return ((a
>> n
) | (a
<< (64 - n
)));
44 * ciphers for use on cpu
51 * hashes for use on cpu
55 #include "cpu-sha256.c"
63 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
69 for (int i
= 0; i
< last_len
; i
++)
79 int max_len
= (int) sizeof (s
);
81 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
83 if (len
> max_len
) len
= max_len
;
85 fwrite (s
, len
, 1, fp
);
92 void log_out_nn (FILE *fp
, const char *fmt
, ...)
94 if (SUPPRESS_OUTPUT
) return;
100 log_final (fp
, fmt
, ap
);
105 void log_info_nn (const char *fmt
, ...)
107 if (SUPPRESS_OUTPUT
) return;
113 log_final (stdout
, fmt
, ap
);
118 void log_error_nn (const char *fmt
, ...)
120 if (SUPPRESS_OUTPUT
) return;
126 log_final (stderr
, fmt
, ap
);
131 void log_out (FILE *fp
, const char *fmt
, ...)
133 if (SUPPRESS_OUTPUT
) return;
139 log_final (fp
, fmt
, ap
);
148 void log_info (const char *fmt
, ...)
150 if (SUPPRESS_OUTPUT
) return;
156 log_final (stdout
, fmt
, ap
);
160 fputc ('\n', stdout
);
165 void log_error (const char *fmt
, ...)
167 if (SUPPRESS_OUTPUT
) return;
169 fputc ('\n', stderr
);
170 fputc ('\n', stderr
);
176 log_final (stderr
, fmt
, ap
);
180 fputc ('\n', stderr
);
181 fputc ('\n', stderr
);
190 uint
byte_swap_32 (const uint n
)
192 return (n
& 0xff000000) >> 24
193 | (n
& 0x00ff0000) >> 8
194 | (n
& 0x0000ff00) << 8
195 | (n
& 0x000000ff) << 24;
198 uint64_t byte_swap_64 (const uint64_t n
)
200 return (n
& 0xff00000000000000ULL
) >> 56
201 | (n
& 0x00ff000000000000ULL
) >> 40
202 | (n
& 0x0000ff0000000000ULL
) >> 24
203 | (n
& 0x000000ff00000000ULL
) >> 8
204 | (n
& 0x00000000ff000000ULL
) << 8
205 | (n
& 0x0000000000ff0000ULL
) << 24
206 | (n
& 0x000000000000ff00ULL
) << 40
207 | (n
& 0x00000000000000ffULL
) << 56;
210 char int_to_base32 (const char c
)
212 static const char tbl
[0x20] =
214 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
215 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
218 return tbl
[(const uint8_t) c
];
221 char base32_to_int (const char c
)
223 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
224 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
229 char int_to_itoa32 (const char c
)
231 static const char tbl
[0x20] =
233 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
234 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
237 return tbl
[(const uint8_t) c
];
240 char itoa32_to_int (const char c
)
242 if ((c
>= '0') && (c
<= '9')) return c
- '0';
243 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
248 char int_to_itoa64 (const char c
)
250 static const char tbl
[0x40] =
252 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
253 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
254 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
255 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
258 return tbl
[(const uint8_t) c
];
261 char itoa64_to_int (const char c
)
263 static const char tbl
[0x100] =
265 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
266 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
267 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
268 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
269 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
270 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
271 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
272 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
273 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
274 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
275 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
276 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
277 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
278 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
279 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
280 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 return tbl
[(const uint8_t) c
];
286 char int_to_base64 (const char c
)
288 static const char tbl
[0x40] =
290 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
291 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
292 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
293 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
296 return tbl
[(const uint8_t) c
];
299 char base64_to_int (const char c
)
301 static const char tbl
[0x100] =
303 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
306 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
308 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
310 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 return tbl
[(const uint8_t) c
];
324 char int_to_bf64 (const char c
)
326 static const char tbl
[0x40] =
328 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
329 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
330 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
331 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
334 return tbl
[(const uint8_t) c
];
337 char bf64_to_int (const char c
)
339 static const char tbl
[0x100] =
341 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
344 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
346 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
348 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 return tbl
[(const uint8_t) c
];
362 char int_to_lotus64 (const char c
)
364 if (c
< 10) return '0' + c
;
365 else if (c
< 36) return 'A' + c
- 10;
366 else if (c
< 62) return 'a' + c
- 36;
367 else if (c
== 62) return '+';
368 else if (c
== 63) return '/';
373 char lotus64_to_int (const char c
)
375 if ((c
>= '0') && (c
<= '9')) return c
- '0';
376 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
377 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
378 else if (c
== '+') return 62;
379 else if (c
== '/') return 63;
385 int base32_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
387 char *in_ptr
= in_buf
;
389 char *out_ptr
= out_buf
;
391 for (int i
= 0; i
< in_len
; i
+= 8)
393 char out_val0
= f (in_ptr
[0] & 0x7f);
394 char out_val1
= f (in_ptr
[1] & 0x7f);
395 char out_val2
= f (in_ptr
[2] & 0x7f);
396 char out_val3
= f (in_ptr
[3] & 0x7f);
397 char out_val4
= f (in_ptr
[4] & 0x7f);
398 char out_val5
= f (in_ptr
[5] & 0x7f);
399 char out_val6
= f (in_ptr
[6] & 0x7f);
400 char out_val7
= f (in_ptr
[7] & 0x7f);
402 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
403 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
404 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
405 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
406 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
412 for (int i
= 0; i
< in_len
; i
++)
414 if (in_buf
[i
] != '=') continue;
419 int out_len
= (in_len
* 5) / 8;
424 int base32_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
426 char *in_ptr
= in_buf
;
428 char *out_ptr
= out_buf
;
430 for (int i
= 0; i
< in_len
; i
+= 5)
432 char out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
433 char out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
434 char out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
435 char out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
436 char out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
437 char out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
438 char out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
439 char out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
441 out_ptr
[0] = out_val0
& 0x7f;
442 out_ptr
[1] = out_val1
& 0x7f;
443 out_ptr
[2] = out_val2
& 0x7f;
444 out_ptr
[3] = out_val3
& 0x7f;
445 out_ptr
[4] = out_val4
& 0x7f;
446 out_ptr
[5] = out_val5
& 0x7f;
447 out_ptr
[6] = out_val6
& 0x7f;
448 out_ptr
[7] = out_val7
& 0x7f;
454 int out_len
= (in_len
* 8) / 5;
456 for (int i
= 0; i
< (7 - (in_len
% 7)); i
++)
460 out_buf
[out_len
] = '=';
466 int base64_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
468 char *in_ptr
= in_buf
;
470 char *out_ptr
= out_buf
;
472 for (int i
= 0; i
< in_len
; i
+= 4)
474 char out_val0
= f (in_ptr
[0] & 0x7f);
475 char out_val1
= f (in_ptr
[1] & 0x7f);
476 char out_val2
= f (in_ptr
[2] & 0x7f);
477 char out_val3
= f (in_ptr
[3] & 0x7f);
479 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
480 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
481 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
487 for (int i
= 0; i
< in_len
; i
++)
489 if (in_buf
[i
] != '=') continue;
494 int out_len
= (in_len
* 6) / 8;
499 int base64_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
501 char *in_ptr
= in_buf
;
503 char *out_ptr
= out_buf
;
505 for (int i
= 0; i
< in_len
; i
+= 3)
507 char out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
508 char out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
509 char out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
510 char out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
512 out_ptr
[0] = out_val0
& 0x7f;
513 out_ptr
[1] = out_val1
& 0x7f;
514 out_ptr
[2] = out_val2
& 0x7f;
515 out_ptr
[3] = out_val3
& 0x7f;
521 int out_len
= (in_len
* 8) / 6;
523 for (int i
= 0; i
< (3 - (in_len
% 3)); i
++)
527 out_buf
[out_len
] = '=';
533 static void AES128_decrypt_cbc (const uint key
[4], const uint iv
[4], const uint in
[16], uint out
[16])
537 AES_set_decrypt_key ((unsigned char *) key
, 128, &skey
);
546 for (int i
= 0; i
< 16; i
+= 4)
556 AES_decrypt (&skey
, (char *) _in
, (char *) _out
);
563 out
[i
+ 0] = _out
[0];
564 out
[i
+ 1] = _out
[1];
565 out
[i
+ 2] = _out
[2];
566 out
[i
+ 3] = _out
[3];
575 static void juniper_decrypt_hash (char *in
, char *out
)
579 char base64_buf
[100];
581 memset (base64_buf
, 0, sizeof (base64_buf
));
583 base64_decode (base64_to_int
, in
, DISPLAY_LEN_MIN_501
, base64_buf
);
587 uint juniper_iv
[4] = { 0 };
589 memcpy (juniper_iv
, base64_buf
, 12);
591 memcpy (out
, juniper_iv
, 12);
597 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
598 juniper_key
[1] = byte_swap_32 (0x8df91059);
599 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
600 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
604 uint
*in_ptr
= (uint
*) (base64_buf
+ 12);
605 uint
*out_ptr
= (uint
*) (out
+ 12);
607 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
610 uint
is_valid_hex_char (const char c
)
612 if ((c
>= '0') && (c
<= '9')) return 1;
613 if ((c
>= 'A') && (c
<= 'F')) return 1;
614 if ((c
>= 'a') && (c
<= 'f')) return 1;
619 char hex_convert (const char c
)
621 return (c
& 15) + (c
>> 6) * 9;
624 char hex_to_char (const char hex
[2])
628 v
|= (hex_convert (hex
[1]) << 0);
629 v
|= (hex_convert (hex
[0]) << 4);
634 uint
hex_to_uint (const char hex
[8])
638 v
|= hex_convert (hex
[7]) << 0;
639 v
|= hex_convert (hex
[6]) << 4;
640 v
|= hex_convert (hex
[5]) << 8;
641 v
|= hex_convert (hex
[4]) << 12;
642 v
|= hex_convert (hex
[3]) << 16;
643 v
|= hex_convert (hex
[2]) << 20;
644 v
|= hex_convert (hex
[1]) << 24;
645 v
|= hex_convert (hex
[0]) << 28;
650 uint64_t hex_to_uint64_t (const char hex
[16])
654 v
|= ((uint64_t) hex_convert (hex
[15]) << 0);
655 v
|= ((uint64_t) hex_convert (hex
[14]) << 4);
656 v
|= ((uint64_t) hex_convert (hex
[13]) << 8);
657 v
|= ((uint64_t) hex_convert (hex
[12]) << 12);
658 v
|= ((uint64_t) hex_convert (hex
[11]) << 16);
659 v
|= ((uint64_t) hex_convert (hex
[10]) << 20);
660 v
|= ((uint64_t) hex_convert (hex
[ 9]) << 24);
661 v
|= ((uint64_t) hex_convert (hex
[ 8]) << 28);
662 v
|= ((uint64_t) hex_convert (hex
[ 7]) << 32);
663 v
|= ((uint64_t) hex_convert (hex
[ 6]) << 36);
664 v
|= ((uint64_t) hex_convert (hex
[ 5]) << 40);
665 v
|= ((uint64_t) hex_convert (hex
[ 4]) << 44);
666 v
|= ((uint64_t) hex_convert (hex
[ 3]) << 48);
667 v
|= ((uint64_t) hex_convert (hex
[ 2]) << 52);
668 v
|= ((uint64_t) hex_convert (hex
[ 1]) << 56);
669 v
|= ((uint64_t) hex_convert (hex
[ 0]) << 60);
674 void bin_to_hex_lower (uint v
, char hex
[8])
676 hex
[0] = v
>> 28 & 15;
677 hex
[1] = v
>> 24 & 15;
678 hex
[2] = v
>> 20 & 15;
679 hex
[3] = v
>> 16 & 15;
680 hex
[4] = v
>> 12 & 15;
681 hex
[5] = v
>> 8 & 15;
682 hex
[6] = v
>> 4 & 15;
683 hex
[7] = v
>> 0 & 15;
687 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
688 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
689 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
690 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
691 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
692 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
693 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
694 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
697 void phpass_decode (unsigned char digest
[16], unsigned char buf
[22])
701 l
= itoa64_to_int (buf
[ 0]) << 0;
702 l
|= itoa64_to_int (buf
[ 1]) << 6;
703 l
|= itoa64_to_int (buf
[ 2]) << 12;
704 l
|= itoa64_to_int (buf
[ 3]) << 18;
706 digest
[ 0] = (l
>> 0) & 0xff;
707 digest
[ 1] = (l
>> 8) & 0xff;
708 digest
[ 2] = (l
>> 16) & 0xff;
710 l
= itoa64_to_int (buf
[ 4]) << 0;
711 l
|= itoa64_to_int (buf
[ 5]) << 6;
712 l
|= itoa64_to_int (buf
[ 6]) << 12;
713 l
|= itoa64_to_int (buf
[ 7]) << 18;
715 digest
[ 3] = (l
>> 0) & 0xff;
716 digest
[ 4] = (l
>> 8) & 0xff;
717 digest
[ 5] = (l
>> 16) & 0xff;
719 l
= itoa64_to_int (buf
[ 8]) << 0;
720 l
|= itoa64_to_int (buf
[ 9]) << 6;
721 l
|= itoa64_to_int (buf
[10]) << 12;
722 l
|= itoa64_to_int (buf
[11]) << 18;
724 digest
[ 6] = (l
>> 0) & 0xff;
725 digest
[ 7] = (l
>> 8) & 0xff;
726 digest
[ 8] = (l
>> 16) & 0xff;
728 l
= itoa64_to_int (buf
[12]) << 0;
729 l
|= itoa64_to_int (buf
[13]) << 6;
730 l
|= itoa64_to_int (buf
[14]) << 12;
731 l
|= itoa64_to_int (buf
[15]) << 18;
733 digest
[ 9] = (l
>> 0) & 0xff;
734 digest
[10] = (l
>> 8) & 0xff;
735 digest
[11] = (l
>> 16) & 0xff;
737 l
= itoa64_to_int (buf
[16]) << 0;
738 l
|= itoa64_to_int (buf
[17]) << 6;
739 l
|= itoa64_to_int (buf
[18]) << 12;
740 l
|= itoa64_to_int (buf
[19]) << 18;
742 digest
[12] = (l
>> 0) & 0xff;
743 digest
[13] = (l
>> 8) & 0xff;
744 digest
[14] = (l
>> 16) & 0xff;
746 l
= itoa64_to_int (buf
[20]) << 0;
747 l
|= itoa64_to_int (buf
[21]) << 6;
749 digest
[15] = (l
>> 0) & 0xff;
752 void phpass_encode (unsigned char digest
[16], unsigned char buf
[22])
756 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
758 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
759 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
760 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
761 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
763 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
765 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
770 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
772 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[11] = int_to_itoa64 (l
& 0x3f);
777 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
779 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[15] = int_to_itoa64 (l
& 0x3f);
784 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
786 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[19] = int_to_itoa64 (l
& 0x3f);
791 l
= (digest
[15] << 0);
793 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[21] = int_to_itoa64 (l
& 0x3f);
797 void md5crypt_decode (unsigned char digest
[16], unsigned char buf
[22])
801 l
= itoa64_to_int (buf
[ 0]) << 0;
802 l
|= itoa64_to_int (buf
[ 1]) << 6;
803 l
|= itoa64_to_int (buf
[ 2]) << 12;
804 l
|= itoa64_to_int (buf
[ 3]) << 18;
806 digest
[ 0] = (l
>> 16) & 0xff;
807 digest
[ 6] = (l
>> 8) & 0xff;
808 digest
[12] = (l
>> 0) & 0xff;
810 l
= itoa64_to_int (buf
[ 4]) << 0;
811 l
|= itoa64_to_int (buf
[ 5]) << 6;
812 l
|= itoa64_to_int (buf
[ 6]) << 12;
813 l
|= itoa64_to_int (buf
[ 7]) << 18;
815 digest
[ 1] = (l
>> 16) & 0xff;
816 digest
[ 7] = (l
>> 8) & 0xff;
817 digest
[13] = (l
>> 0) & 0xff;
819 l
= itoa64_to_int (buf
[ 8]) << 0;
820 l
|= itoa64_to_int (buf
[ 9]) << 6;
821 l
|= itoa64_to_int (buf
[10]) << 12;
822 l
|= itoa64_to_int (buf
[11]) << 18;
824 digest
[ 2] = (l
>> 16) & 0xff;
825 digest
[ 8] = (l
>> 8) & 0xff;
826 digest
[14] = (l
>> 0) & 0xff;
828 l
= itoa64_to_int (buf
[12]) << 0;
829 l
|= itoa64_to_int (buf
[13]) << 6;
830 l
|= itoa64_to_int (buf
[14]) << 12;
831 l
|= itoa64_to_int (buf
[15]) << 18;
833 digest
[ 3] = (l
>> 16) & 0xff;
834 digest
[ 9] = (l
>> 8) & 0xff;
835 digest
[15] = (l
>> 0) & 0xff;
837 l
= itoa64_to_int (buf
[16]) << 0;
838 l
|= itoa64_to_int (buf
[17]) << 6;
839 l
|= itoa64_to_int (buf
[18]) << 12;
840 l
|= itoa64_to_int (buf
[19]) << 18;
842 digest
[ 4] = (l
>> 16) & 0xff;
843 digest
[10] = (l
>> 8) & 0xff;
844 digest
[ 5] = (l
>> 0) & 0xff;
846 l
= itoa64_to_int (buf
[20]) << 0;
847 l
|= itoa64_to_int (buf
[21]) << 6;
849 digest
[11] = (l
>> 0) & 0xff;
852 void md5crypt_encode (unsigned char digest
[16], unsigned char buf
[22])
856 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
858 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
859 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
860 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
865 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
872 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
879 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
886 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 l
= (digest
[11] << 0);
893 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 void sha512crypt_decode (unsigned char digest
[64], unsigned char buf
[86])
901 l
= itoa64_to_int (buf
[ 0]) << 0;
902 l
|= itoa64_to_int (buf
[ 1]) << 6;
903 l
|= itoa64_to_int (buf
[ 2]) << 12;
904 l
|= itoa64_to_int (buf
[ 3]) << 18;
906 digest
[ 0] = (l
>> 16) & 0xff;
907 digest
[21] = (l
>> 8) & 0xff;
908 digest
[42] = (l
>> 0) & 0xff;
910 l
= itoa64_to_int (buf
[ 4]) << 0;
911 l
|= itoa64_to_int (buf
[ 5]) << 6;
912 l
|= itoa64_to_int (buf
[ 6]) << 12;
913 l
|= itoa64_to_int (buf
[ 7]) << 18;
915 digest
[22] = (l
>> 16) & 0xff;
916 digest
[43] = (l
>> 8) & 0xff;
917 digest
[ 1] = (l
>> 0) & 0xff;
919 l
= itoa64_to_int (buf
[ 8]) << 0;
920 l
|= itoa64_to_int (buf
[ 9]) << 6;
921 l
|= itoa64_to_int (buf
[10]) << 12;
922 l
|= itoa64_to_int (buf
[11]) << 18;
924 digest
[44] = (l
>> 16) & 0xff;
925 digest
[ 2] = (l
>> 8) & 0xff;
926 digest
[23] = (l
>> 0) & 0xff;
928 l
= itoa64_to_int (buf
[12]) << 0;
929 l
|= itoa64_to_int (buf
[13]) << 6;
930 l
|= itoa64_to_int (buf
[14]) << 12;
931 l
|= itoa64_to_int (buf
[15]) << 18;
933 digest
[ 3] = (l
>> 16) & 0xff;
934 digest
[24] = (l
>> 8) & 0xff;
935 digest
[45] = (l
>> 0) & 0xff;
937 l
= itoa64_to_int (buf
[16]) << 0;
938 l
|= itoa64_to_int (buf
[17]) << 6;
939 l
|= itoa64_to_int (buf
[18]) << 12;
940 l
|= itoa64_to_int (buf
[19]) << 18;
942 digest
[25] = (l
>> 16) & 0xff;
943 digest
[46] = (l
>> 8) & 0xff;
944 digest
[ 4] = (l
>> 0) & 0xff;
946 l
= itoa64_to_int (buf
[20]) << 0;
947 l
|= itoa64_to_int (buf
[21]) << 6;
948 l
|= itoa64_to_int (buf
[22]) << 12;
949 l
|= itoa64_to_int (buf
[23]) << 18;
951 digest
[47] = (l
>> 16) & 0xff;
952 digest
[ 5] = (l
>> 8) & 0xff;
953 digest
[26] = (l
>> 0) & 0xff;
955 l
= itoa64_to_int (buf
[24]) << 0;
956 l
|= itoa64_to_int (buf
[25]) << 6;
957 l
|= itoa64_to_int (buf
[26]) << 12;
958 l
|= itoa64_to_int (buf
[27]) << 18;
960 digest
[ 6] = (l
>> 16) & 0xff;
961 digest
[27] = (l
>> 8) & 0xff;
962 digest
[48] = (l
>> 0) & 0xff;
964 l
= itoa64_to_int (buf
[28]) << 0;
965 l
|= itoa64_to_int (buf
[29]) << 6;
966 l
|= itoa64_to_int (buf
[30]) << 12;
967 l
|= itoa64_to_int (buf
[31]) << 18;
969 digest
[28] = (l
>> 16) & 0xff;
970 digest
[49] = (l
>> 8) & 0xff;
971 digest
[ 7] = (l
>> 0) & 0xff;
973 l
= itoa64_to_int (buf
[32]) << 0;
974 l
|= itoa64_to_int (buf
[33]) << 6;
975 l
|= itoa64_to_int (buf
[34]) << 12;
976 l
|= itoa64_to_int (buf
[35]) << 18;
978 digest
[50] = (l
>> 16) & 0xff;
979 digest
[ 8] = (l
>> 8) & 0xff;
980 digest
[29] = (l
>> 0) & 0xff;
982 l
= itoa64_to_int (buf
[36]) << 0;
983 l
|= itoa64_to_int (buf
[37]) << 6;
984 l
|= itoa64_to_int (buf
[38]) << 12;
985 l
|= itoa64_to_int (buf
[39]) << 18;
987 digest
[ 9] = (l
>> 16) & 0xff;
988 digest
[30] = (l
>> 8) & 0xff;
989 digest
[51] = (l
>> 0) & 0xff;
991 l
= itoa64_to_int (buf
[40]) << 0;
992 l
|= itoa64_to_int (buf
[41]) << 6;
993 l
|= itoa64_to_int (buf
[42]) << 12;
994 l
|= itoa64_to_int (buf
[43]) << 18;
996 digest
[31] = (l
>> 16) & 0xff;
997 digest
[52] = (l
>> 8) & 0xff;
998 digest
[10] = (l
>> 0) & 0xff;
1000 l
= itoa64_to_int (buf
[44]) << 0;
1001 l
|= itoa64_to_int (buf
[45]) << 6;
1002 l
|= itoa64_to_int (buf
[46]) << 12;
1003 l
|= itoa64_to_int (buf
[47]) << 18;
1005 digest
[53] = (l
>> 16) & 0xff;
1006 digest
[11] = (l
>> 8) & 0xff;
1007 digest
[32] = (l
>> 0) & 0xff;
1009 l
= itoa64_to_int (buf
[48]) << 0;
1010 l
|= itoa64_to_int (buf
[49]) << 6;
1011 l
|= itoa64_to_int (buf
[50]) << 12;
1012 l
|= itoa64_to_int (buf
[51]) << 18;
1014 digest
[12] = (l
>> 16) & 0xff;
1015 digest
[33] = (l
>> 8) & 0xff;
1016 digest
[54] = (l
>> 0) & 0xff;
1018 l
= itoa64_to_int (buf
[52]) << 0;
1019 l
|= itoa64_to_int (buf
[53]) << 6;
1020 l
|= itoa64_to_int (buf
[54]) << 12;
1021 l
|= itoa64_to_int (buf
[55]) << 18;
1023 digest
[34] = (l
>> 16) & 0xff;
1024 digest
[55] = (l
>> 8) & 0xff;
1025 digest
[13] = (l
>> 0) & 0xff;
1027 l
= itoa64_to_int (buf
[56]) << 0;
1028 l
|= itoa64_to_int (buf
[57]) << 6;
1029 l
|= itoa64_to_int (buf
[58]) << 12;
1030 l
|= itoa64_to_int (buf
[59]) << 18;
1032 digest
[56] = (l
>> 16) & 0xff;
1033 digest
[14] = (l
>> 8) & 0xff;
1034 digest
[35] = (l
>> 0) & 0xff;
1036 l
= itoa64_to_int (buf
[60]) << 0;
1037 l
|= itoa64_to_int (buf
[61]) << 6;
1038 l
|= itoa64_to_int (buf
[62]) << 12;
1039 l
|= itoa64_to_int (buf
[63]) << 18;
1041 digest
[15] = (l
>> 16) & 0xff;
1042 digest
[36] = (l
>> 8) & 0xff;
1043 digest
[57] = (l
>> 0) & 0xff;
1045 l
= itoa64_to_int (buf
[64]) << 0;
1046 l
|= itoa64_to_int (buf
[65]) << 6;
1047 l
|= itoa64_to_int (buf
[66]) << 12;
1048 l
|= itoa64_to_int (buf
[67]) << 18;
1050 digest
[37] = (l
>> 16) & 0xff;
1051 digest
[58] = (l
>> 8) & 0xff;
1052 digest
[16] = (l
>> 0) & 0xff;
1054 l
= itoa64_to_int (buf
[68]) << 0;
1055 l
|= itoa64_to_int (buf
[69]) << 6;
1056 l
|= itoa64_to_int (buf
[70]) << 12;
1057 l
|= itoa64_to_int (buf
[71]) << 18;
1059 digest
[59] = (l
>> 16) & 0xff;
1060 digest
[17] = (l
>> 8) & 0xff;
1061 digest
[38] = (l
>> 0) & 0xff;
1063 l
= itoa64_to_int (buf
[72]) << 0;
1064 l
|= itoa64_to_int (buf
[73]) << 6;
1065 l
|= itoa64_to_int (buf
[74]) << 12;
1066 l
|= itoa64_to_int (buf
[75]) << 18;
1068 digest
[18] = (l
>> 16) & 0xff;
1069 digest
[39] = (l
>> 8) & 0xff;
1070 digest
[60] = (l
>> 0) & 0xff;
1072 l
= itoa64_to_int (buf
[76]) << 0;
1073 l
|= itoa64_to_int (buf
[77]) << 6;
1074 l
|= itoa64_to_int (buf
[78]) << 12;
1075 l
|= itoa64_to_int (buf
[79]) << 18;
1077 digest
[40] = (l
>> 16) & 0xff;
1078 digest
[61] = (l
>> 8) & 0xff;
1079 digest
[19] = (l
>> 0) & 0xff;
1081 l
= itoa64_to_int (buf
[80]) << 0;
1082 l
|= itoa64_to_int (buf
[81]) << 6;
1083 l
|= itoa64_to_int (buf
[82]) << 12;
1084 l
|= itoa64_to_int (buf
[83]) << 18;
1086 digest
[62] = (l
>> 16) & 0xff;
1087 digest
[20] = (l
>> 8) & 0xff;
1088 digest
[41] = (l
>> 0) & 0xff;
1090 l
= itoa64_to_int (buf
[84]) << 0;
1091 l
|= itoa64_to_int (buf
[85]) << 6;
1093 digest
[63] = (l
>> 0) & 0xff;
1096 void sha512crypt_encode (unsigned char digest
[64], unsigned char buf
[86])
1100 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1102 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1103 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1104 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1109 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1116 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1123 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1130 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1137 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1144 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1151 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1158 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1165 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1172 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1179 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1186 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1193 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1200 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1207 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1214 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1221 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1228 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1235 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1242 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 l
= 0 | 0 | (digest
[63] << 0);
1249 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 void sha1aix_decode (unsigned char digest
[20], unsigned char buf
[27])
1257 l
= itoa64_to_int (buf
[ 0]) << 0;
1258 l
|= itoa64_to_int (buf
[ 1]) << 6;
1259 l
|= itoa64_to_int (buf
[ 2]) << 12;
1260 l
|= itoa64_to_int (buf
[ 3]) << 18;
1262 digest
[ 2] = (l
>> 0) & 0xff;
1263 digest
[ 1] = (l
>> 8) & 0xff;
1264 digest
[ 0] = (l
>> 16) & 0xff;
1266 l
= itoa64_to_int (buf
[ 4]) << 0;
1267 l
|= itoa64_to_int (buf
[ 5]) << 6;
1268 l
|= itoa64_to_int (buf
[ 6]) << 12;
1269 l
|= itoa64_to_int (buf
[ 7]) << 18;
1271 digest
[ 5] = (l
>> 0) & 0xff;
1272 digest
[ 4] = (l
>> 8) & 0xff;
1273 digest
[ 3] = (l
>> 16) & 0xff;
1275 l
= itoa64_to_int (buf
[ 8]) << 0;
1276 l
|= itoa64_to_int (buf
[ 9]) << 6;
1277 l
|= itoa64_to_int (buf
[10]) << 12;
1278 l
|= itoa64_to_int (buf
[11]) << 18;
1280 digest
[ 8] = (l
>> 0) & 0xff;
1281 digest
[ 7] = (l
>> 8) & 0xff;
1282 digest
[ 6] = (l
>> 16) & 0xff;
1284 l
= itoa64_to_int (buf
[12]) << 0;
1285 l
|= itoa64_to_int (buf
[13]) << 6;
1286 l
|= itoa64_to_int (buf
[14]) << 12;
1287 l
|= itoa64_to_int (buf
[15]) << 18;
1289 digest
[11] = (l
>> 0) & 0xff;
1290 digest
[10] = (l
>> 8) & 0xff;
1291 digest
[ 9] = (l
>> 16) & 0xff;
1293 l
= itoa64_to_int (buf
[16]) << 0;
1294 l
|= itoa64_to_int (buf
[17]) << 6;
1295 l
|= itoa64_to_int (buf
[18]) << 12;
1296 l
|= itoa64_to_int (buf
[19]) << 18;
1298 digest
[14] = (l
>> 0) & 0xff;
1299 digest
[13] = (l
>> 8) & 0xff;
1300 digest
[12] = (l
>> 16) & 0xff;
1302 l
= itoa64_to_int (buf
[20]) << 0;
1303 l
|= itoa64_to_int (buf
[21]) << 6;
1304 l
|= itoa64_to_int (buf
[22]) << 12;
1305 l
|= itoa64_to_int (buf
[23]) << 18;
1307 digest
[17] = (l
>> 0) & 0xff;
1308 digest
[16] = (l
>> 8) & 0xff;
1309 digest
[15] = (l
>> 16) & 0xff;
1311 l
= itoa64_to_int (buf
[24]) << 0;
1312 l
|= itoa64_to_int (buf
[25]) << 6;
1313 l
|= itoa64_to_int (buf
[26]) << 12;
1315 digest
[19] = (l
>> 8) & 0xff;
1316 digest
[18] = (l
>> 16) & 0xff;
1319 void sha1aix_encode (unsigned char digest
[20], unsigned char buf
[27])
1323 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1325 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1326 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1327 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1328 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1330 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1332 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1337 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1339 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[11] = int_to_itoa64 (l
& 0x3f);
1344 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1346 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[15] = int_to_itoa64 (l
& 0x3f);
1351 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1353 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[19] = int_to_itoa64 (l
& 0x3f);
1358 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1360 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[23] = int_to_itoa64 (l
& 0x3f);
1365 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1367 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[26] = int_to_itoa64 (l
& 0x3f);
1372 void sha256aix_decode (unsigned char digest
[32], unsigned char buf
[43])
1376 l
= itoa64_to_int (buf
[ 0]) << 0;
1377 l
|= itoa64_to_int (buf
[ 1]) << 6;
1378 l
|= itoa64_to_int (buf
[ 2]) << 12;
1379 l
|= itoa64_to_int (buf
[ 3]) << 18;
1381 digest
[ 2] = (l
>> 0) & 0xff;
1382 digest
[ 1] = (l
>> 8) & 0xff;
1383 digest
[ 0] = (l
>> 16) & 0xff;
1385 l
= itoa64_to_int (buf
[ 4]) << 0;
1386 l
|= itoa64_to_int (buf
[ 5]) << 6;
1387 l
|= itoa64_to_int (buf
[ 6]) << 12;
1388 l
|= itoa64_to_int (buf
[ 7]) << 18;
1390 digest
[ 5] = (l
>> 0) & 0xff;
1391 digest
[ 4] = (l
>> 8) & 0xff;
1392 digest
[ 3] = (l
>> 16) & 0xff;
1394 l
= itoa64_to_int (buf
[ 8]) << 0;
1395 l
|= itoa64_to_int (buf
[ 9]) << 6;
1396 l
|= itoa64_to_int (buf
[10]) << 12;
1397 l
|= itoa64_to_int (buf
[11]) << 18;
1399 digest
[ 8] = (l
>> 0) & 0xff;
1400 digest
[ 7] = (l
>> 8) & 0xff;
1401 digest
[ 6] = (l
>> 16) & 0xff;
1403 l
= itoa64_to_int (buf
[12]) << 0;
1404 l
|= itoa64_to_int (buf
[13]) << 6;
1405 l
|= itoa64_to_int (buf
[14]) << 12;
1406 l
|= itoa64_to_int (buf
[15]) << 18;
1408 digest
[11] = (l
>> 0) & 0xff;
1409 digest
[10] = (l
>> 8) & 0xff;
1410 digest
[ 9] = (l
>> 16) & 0xff;
1412 l
= itoa64_to_int (buf
[16]) << 0;
1413 l
|= itoa64_to_int (buf
[17]) << 6;
1414 l
|= itoa64_to_int (buf
[18]) << 12;
1415 l
|= itoa64_to_int (buf
[19]) << 18;
1417 digest
[14] = (l
>> 0) & 0xff;
1418 digest
[13] = (l
>> 8) & 0xff;
1419 digest
[12] = (l
>> 16) & 0xff;
1421 l
= itoa64_to_int (buf
[20]) << 0;
1422 l
|= itoa64_to_int (buf
[21]) << 6;
1423 l
|= itoa64_to_int (buf
[22]) << 12;
1424 l
|= itoa64_to_int (buf
[23]) << 18;
1426 digest
[17] = (l
>> 0) & 0xff;
1427 digest
[16] = (l
>> 8) & 0xff;
1428 digest
[15] = (l
>> 16) & 0xff;
1430 l
= itoa64_to_int (buf
[24]) << 0;
1431 l
|= itoa64_to_int (buf
[25]) << 6;
1432 l
|= itoa64_to_int (buf
[26]) << 12;
1433 l
|= itoa64_to_int (buf
[27]) << 18;
1435 digest
[20] = (l
>> 0) & 0xff;
1436 digest
[19] = (l
>> 8) & 0xff;
1437 digest
[18] = (l
>> 16) & 0xff;
1439 l
= itoa64_to_int (buf
[28]) << 0;
1440 l
|= itoa64_to_int (buf
[29]) << 6;
1441 l
|= itoa64_to_int (buf
[30]) << 12;
1442 l
|= itoa64_to_int (buf
[31]) << 18;
1444 digest
[23] = (l
>> 0) & 0xff;
1445 digest
[22] = (l
>> 8) & 0xff;
1446 digest
[21] = (l
>> 16) & 0xff;
1448 l
= itoa64_to_int (buf
[32]) << 0;
1449 l
|= itoa64_to_int (buf
[33]) << 6;
1450 l
|= itoa64_to_int (buf
[34]) << 12;
1451 l
|= itoa64_to_int (buf
[35]) << 18;
1453 digest
[26] = (l
>> 0) & 0xff;
1454 digest
[25] = (l
>> 8) & 0xff;
1455 digest
[24] = (l
>> 16) & 0xff;
1457 l
= itoa64_to_int (buf
[36]) << 0;
1458 l
|= itoa64_to_int (buf
[37]) << 6;
1459 l
|= itoa64_to_int (buf
[38]) << 12;
1460 l
|= itoa64_to_int (buf
[39]) << 18;
1462 digest
[29] = (l
>> 0) & 0xff;
1463 digest
[28] = (l
>> 8) & 0xff;
1464 digest
[27] = (l
>> 16) & 0xff;
1466 l
= itoa64_to_int (buf
[40]) << 0;
1467 l
|= itoa64_to_int (buf
[41]) << 6;
1468 l
|= itoa64_to_int (buf
[42]) << 12;
1470 //digest[32] = (l >> 0) & 0xff;
1471 digest
[31] = (l
>> 8) & 0xff;
1472 digest
[30] = (l
>> 16) & 0xff;
1475 void sha256aix_encode (unsigned char digest
[32], unsigned char buf
[43])
1479 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1481 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1482 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1483 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1484 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1486 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1488 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1493 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1495 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[11] = int_to_itoa64 (l
& 0x3f);
1500 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1502 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[15] = int_to_itoa64 (l
& 0x3f);
1507 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1509 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[19] = int_to_itoa64 (l
& 0x3f);
1514 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1516 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[23] = int_to_itoa64 (l
& 0x3f);
1521 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1523 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[27] = int_to_itoa64 (l
& 0x3f);
1528 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1530 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[31] = int_to_itoa64 (l
& 0x3f);
1535 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1537 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[35] = int_to_itoa64 (l
& 0x3f);
1542 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1544 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[39] = int_to_itoa64 (l
& 0x3f);
1549 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1551 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[42] = int_to_itoa64 (l
& 0x3f);
1556 void sha512aix_decode (unsigned char digest
[64], unsigned char buf
[86])
1560 l
= itoa64_to_int (buf
[ 0]) << 0;
1561 l
|= itoa64_to_int (buf
[ 1]) << 6;
1562 l
|= itoa64_to_int (buf
[ 2]) << 12;
1563 l
|= itoa64_to_int (buf
[ 3]) << 18;
1565 digest
[ 2] = (l
>> 0) & 0xff;
1566 digest
[ 1] = (l
>> 8) & 0xff;
1567 digest
[ 0] = (l
>> 16) & 0xff;
1569 l
= itoa64_to_int (buf
[ 4]) << 0;
1570 l
|= itoa64_to_int (buf
[ 5]) << 6;
1571 l
|= itoa64_to_int (buf
[ 6]) << 12;
1572 l
|= itoa64_to_int (buf
[ 7]) << 18;
1574 digest
[ 5] = (l
>> 0) & 0xff;
1575 digest
[ 4] = (l
>> 8) & 0xff;
1576 digest
[ 3] = (l
>> 16) & 0xff;
1578 l
= itoa64_to_int (buf
[ 8]) << 0;
1579 l
|= itoa64_to_int (buf
[ 9]) << 6;
1580 l
|= itoa64_to_int (buf
[10]) << 12;
1581 l
|= itoa64_to_int (buf
[11]) << 18;
1583 digest
[ 8] = (l
>> 0) & 0xff;
1584 digest
[ 7] = (l
>> 8) & 0xff;
1585 digest
[ 6] = (l
>> 16) & 0xff;
1587 l
= itoa64_to_int (buf
[12]) << 0;
1588 l
|= itoa64_to_int (buf
[13]) << 6;
1589 l
|= itoa64_to_int (buf
[14]) << 12;
1590 l
|= itoa64_to_int (buf
[15]) << 18;
1592 digest
[11] = (l
>> 0) & 0xff;
1593 digest
[10] = (l
>> 8) & 0xff;
1594 digest
[ 9] = (l
>> 16) & 0xff;
1596 l
= itoa64_to_int (buf
[16]) << 0;
1597 l
|= itoa64_to_int (buf
[17]) << 6;
1598 l
|= itoa64_to_int (buf
[18]) << 12;
1599 l
|= itoa64_to_int (buf
[19]) << 18;
1601 digest
[14] = (l
>> 0) & 0xff;
1602 digest
[13] = (l
>> 8) & 0xff;
1603 digest
[12] = (l
>> 16) & 0xff;
1605 l
= itoa64_to_int (buf
[20]) << 0;
1606 l
|= itoa64_to_int (buf
[21]) << 6;
1607 l
|= itoa64_to_int (buf
[22]) << 12;
1608 l
|= itoa64_to_int (buf
[23]) << 18;
1610 digest
[17] = (l
>> 0) & 0xff;
1611 digest
[16] = (l
>> 8) & 0xff;
1612 digest
[15] = (l
>> 16) & 0xff;
1614 l
= itoa64_to_int (buf
[24]) << 0;
1615 l
|= itoa64_to_int (buf
[25]) << 6;
1616 l
|= itoa64_to_int (buf
[26]) << 12;
1617 l
|= itoa64_to_int (buf
[27]) << 18;
1619 digest
[20] = (l
>> 0) & 0xff;
1620 digest
[19] = (l
>> 8) & 0xff;
1621 digest
[18] = (l
>> 16) & 0xff;
1623 l
= itoa64_to_int (buf
[28]) << 0;
1624 l
|= itoa64_to_int (buf
[29]) << 6;
1625 l
|= itoa64_to_int (buf
[30]) << 12;
1626 l
|= itoa64_to_int (buf
[31]) << 18;
1628 digest
[23] = (l
>> 0) & 0xff;
1629 digest
[22] = (l
>> 8) & 0xff;
1630 digest
[21] = (l
>> 16) & 0xff;
1632 l
= itoa64_to_int (buf
[32]) << 0;
1633 l
|= itoa64_to_int (buf
[33]) << 6;
1634 l
|= itoa64_to_int (buf
[34]) << 12;
1635 l
|= itoa64_to_int (buf
[35]) << 18;
1637 digest
[26] = (l
>> 0) & 0xff;
1638 digest
[25] = (l
>> 8) & 0xff;
1639 digest
[24] = (l
>> 16) & 0xff;
1641 l
= itoa64_to_int (buf
[36]) << 0;
1642 l
|= itoa64_to_int (buf
[37]) << 6;
1643 l
|= itoa64_to_int (buf
[38]) << 12;
1644 l
|= itoa64_to_int (buf
[39]) << 18;
1646 digest
[29] = (l
>> 0) & 0xff;
1647 digest
[28] = (l
>> 8) & 0xff;
1648 digest
[27] = (l
>> 16) & 0xff;
1650 l
= itoa64_to_int (buf
[40]) << 0;
1651 l
|= itoa64_to_int (buf
[41]) << 6;
1652 l
|= itoa64_to_int (buf
[42]) << 12;
1653 l
|= itoa64_to_int (buf
[43]) << 18;
1655 digest
[32] = (l
>> 0) & 0xff;
1656 digest
[31] = (l
>> 8) & 0xff;
1657 digest
[30] = (l
>> 16) & 0xff;
1659 l
= itoa64_to_int (buf
[44]) << 0;
1660 l
|= itoa64_to_int (buf
[45]) << 6;
1661 l
|= itoa64_to_int (buf
[46]) << 12;
1662 l
|= itoa64_to_int (buf
[47]) << 18;
1664 digest
[35] = (l
>> 0) & 0xff;
1665 digest
[34] = (l
>> 8) & 0xff;
1666 digest
[33] = (l
>> 16) & 0xff;
1668 l
= itoa64_to_int (buf
[48]) << 0;
1669 l
|= itoa64_to_int (buf
[49]) << 6;
1670 l
|= itoa64_to_int (buf
[50]) << 12;
1671 l
|= itoa64_to_int (buf
[51]) << 18;
1673 digest
[38] = (l
>> 0) & 0xff;
1674 digest
[37] = (l
>> 8) & 0xff;
1675 digest
[36] = (l
>> 16) & 0xff;
1677 l
= itoa64_to_int (buf
[52]) << 0;
1678 l
|= itoa64_to_int (buf
[53]) << 6;
1679 l
|= itoa64_to_int (buf
[54]) << 12;
1680 l
|= itoa64_to_int (buf
[55]) << 18;
1682 digest
[41] = (l
>> 0) & 0xff;
1683 digest
[40] = (l
>> 8) & 0xff;
1684 digest
[39] = (l
>> 16) & 0xff;
1686 l
= itoa64_to_int (buf
[56]) << 0;
1687 l
|= itoa64_to_int (buf
[57]) << 6;
1688 l
|= itoa64_to_int (buf
[58]) << 12;
1689 l
|= itoa64_to_int (buf
[59]) << 18;
1691 digest
[44] = (l
>> 0) & 0xff;
1692 digest
[43] = (l
>> 8) & 0xff;
1693 digest
[42] = (l
>> 16) & 0xff;
1695 l
= itoa64_to_int (buf
[60]) << 0;
1696 l
|= itoa64_to_int (buf
[61]) << 6;
1697 l
|= itoa64_to_int (buf
[62]) << 12;
1698 l
|= itoa64_to_int (buf
[63]) << 18;
1700 digest
[47] = (l
>> 0) & 0xff;
1701 digest
[46] = (l
>> 8) & 0xff;
1702 digest
[45] = (l
>> 16) & 0xff;
1704 l
= itoa64_to_int (buf
[64]) << 0;
1705 l
|= itoa64_to_int (buf
[65]) << 6;
1706 l
|= itoa64_to_int (buf
[66]) << 12;
1707 l
|= itoa64_to_int (buf
[67]) << 18;
1709 digest
[50] = (l
>> 0) & 0xff;
1710 digest
[49] = (l
>> 8) & 0xff;
1711 digest
[48] = (l
>> 16) & 0xff;
1713 l
= itoa64_to_int (buf
[68]) << 0;
1714 l
|= itoa64_to_int (buf
[69]) << 6;
1715 l
|= itoa64_to_int (buf
[70]) << 12;
1716 l
|= itoa64_to_int (buf
[71]) << 18;
1718 digest
[53] = (l
>> 0) & 0xff;
1719 digest
[52] = (l
>> 8) & 0xff;
1720 digest
[51] = (l
>> 16) & 0xff;
1722 l
= itoa64_to_int (buf
[72]) << 0;
1723 l
|= itoa64_to_int (buf
[73]) << 6;
1724 l
|= itoa64_to_int (buf
[74]) << 12;
1725 l
|= itoa64_to_int (buf
[75]) << 18;
1727 digest
[56] = (l
>> 0) & 0xff;
1728 digest
[55] = (l
>> 8) & 0xff;
1729 digest
[54] = (l
>> 16) & 0xff;
1731 l
= itoa64_to_int (buf
[76]) << 0;
1732 l
|= itoa64_to_int (buf
[77]) << 6;
1733 l
|= itoa64_to_int (buf
[78]) << 12;
1734 l
|= itoa64_to_int (buf
[79]) << 18;
1736 digest
[59] = (l
>> 0) & 0xff;
1737 digest
[58] = (l
>> 8) & 0xff;
1738 digest
[57] = (l
>> 16) & 0xff;
1740 l
= itoa64_to_int (buf
[80]) << 0;
1741 l
|= itoa64_to_int (buf
[81]) << 6;
1742 l
|= itoa64_to_int (buf
[82]) << 12;
1743 l
|= itoa64_to_int (buf
[83]) << 18;
1745 digest
[62] = (l
>> 0) & 0xff;
1746 digest
[61] = (l
>> 8) & 0xff;
1747 digest
[60] = (l
>> 16) & 0xff;
1749 l
= itoa64_to_int (buf
[84]) << 0;
1750 l
|= itoa64_to_int (buf
[85]) << 6;
1752 digest
[63] = (l
>> 16) & 0xff;
1755 void sha512aix_encode (unsigned char digest
[64], unsigned char buf
[86])
1759 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1761 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1762 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1763 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1764 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1766 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1768 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1773 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1775 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[11] = int_to_itoa64 (l
& 0x3f);
1780 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1782 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[15] = int_to_itoa64 (l
& 0x3f);
1787 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1789 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[19] = int_to_itoa64 (l
& 0x3f);
1794 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1796 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[23] = int_to_itoa64 (l
& 0x3f);
1801 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1803 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[27] = int_to_itoa64 (l
& 0x3f);
1808 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1810 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[31] = int_to_itoa64 (l
& 0x3f);
1815 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1817 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[35] = int_to_itoa64 (l
& 0x3f);
1822 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1824 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[39] = int_to_itoa64 (l
& 0x3f);
1829 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1831 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[43] = int_to_itoa64 (l
& 0x3f);
1836 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1838 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[47] = int_to_itoa64 (l
& 0x3f);
1843 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1845 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[51] = int_to_itoa64 (l
& 0x3f);
1850 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1852 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[55] = int_to_itoa64 (l
& 0x3f);
1857 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1859 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[59] = int_to_itoa64 (l
& 0x3f);
1864 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1866 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[63] = int_to_itoa64 (l
& 0x3f);
1871 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1873 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[67] = int_to_itoa64 (l
& 0x3f);
1878 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1880 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[71] = int_to_itoa64 (l
& 0x3f);
1885 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1887 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[75] = int_to_itoa64 (l
& 0x3f);
1892 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1894 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[79] = int_to_itoa64 (l
& 0x3f);
1899 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1901 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[83] = int_to_itoa64 (l
& 0x3f);
1906 l
= 0 | 0 | (digest
[63] << 16);
1908 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 void sha256crypt_decode (unsigned char digest
[32], unsigned char buf
[43])
1916 l
= itoa64_to_int (buf
[ 0]) << 0;
1917 l
|= itoa64_to_int (buf
[ 1]) << 6;
1918 l
|= itoa64_to_int (buf
[ 2]) << 12;
1919 l
|= itoa64_to_int (buf
[ 3]) << 18;
1921 digest
[ 0] = (l
>> 16) & 0xff;
1922 digest
[10] = (l
>> 8) & 0xff;
1923 digest
[20] = (l
>> 0) & 0xff;
1925 l
= itoa64_to_int (buf
[ 4]) << 0;
1926 l
|= itoa64_to_int (buf
[ 5]) << 6;
1927 l
|= itoa64_to_int (buf
[ 6]) << 12;
1928 l
|= itoa64_to_int (buf
[ 7]) << 18;
1930 digest
[21] = (l
>> 16) & 0xff;
1931 digest
[ 1] = (l
>> 8) & 0xff;
1932 digest
[11] = (l
>> 0) & 0xff;
1934 l
= itoa64_to_int (buf
[ 8]) << 0;
1935 l
|= itoa64_to_int (buf
[ 9]) << 6;
1936 l
|= itoa64_to_int (buf
[10]) << 12;
1937 l
|= itoa64_to_int (buf
[11]) << 18;
1939 digest
[12] = (l
>> 16) & 0xff;
1940 digest
[22] = (l
>> 8) & 0xff;
1941 digest
[ 2] = (l
>> 0) & 0xff;
1943 l
= itoa64_to_int (buf
[12]) << 0;
1944 l
|= itoa64_to_int (buf
[13]) << 6;
1945 l
|= itoa64_to_int (buf
[14]) << 12;
1946 l
|= itoa64_to_int (buf
[15]) << 18;
1948 digest
[ 3] = (l
>> 16) & 0xff;
1949 digest
[13] = (l
>> 8) & 0xff;
1950 digest
[23] = (l
>> 0) & 0xff;
1952 l
= itoa64_to_int (buf
[16]) << 0;
1953 l
|= itoa64_to_int (buf
[17]) << 6;
1954 l
|= itoa64_to_int (buf
[18]) << 12;
1955 l
|= itoa64_to_int (buf
[19]) << 18;
1957 digest
[24] = (l
>> 16) & 0xff;
1958 digest
[ 4] = (l
>> 8) & 0xff;
1959 digest
[14] = (l
>> 0) & 0xff;
1961 l
= itoa64_to_int (buf
[20]) << 0;
1962 l
|= itoa64_to_int (buf
[21]) << 6;
1963 l
|= itoa64_to_int (buf
[22]) << 12;
1964 l
|= itoa64_to_int (buf
[23]) << 18;
1966 digest
[15] = (l
>> 16) & 0xff;
1967 digest
[25] = (l
>> 8) & 0xff;
1968 digest
[ 5] = (l
>> 0) & 0xff;
1970 l
= itoa64_to_int (buf
[24]) << 0;
1971 l
|= itoa64_to_int (buf
[25]) << 6;
1972 l
|= itoa64_to_int (buf
[26]) << 12;
1973 l
|= itoa64_to_int (buf
[27]) << 18;
1975 digest
[ 6] = (l
>> 16) & 0xff;
1976 digest
[16] = (l
>> 8) & 0xff;
1977 digest
[26] = (l
>> 0) & 0xff;
1979 l
= itoa64_to_int (buf
[28]) << 0;
1980 l
|= itoa64_to_int (buf
[29]) << 6;
1981 l
|= itoa64_to_int (buf
[30]) << 12;
1982 l
|= itoa64_to_int (buf
[31]) << 18;
1984 digest
[27] = (l
>> 16) & 0xff;
1985 digest
[ 7] = (l
>> 8) & 0xff;
1986 digest
[17] = (l
>> 0) & 0xff;
1988 l
= itoa64_to_int (buf
[32]) << 0;
1989 l
|= itoa64_to_int (buf
[33]) << 6;
1990 l
|= itoa64_to_int (buf
[34]) << 12;
1991 l
|= itoa64_to_int (buf
[35]) << 18;
1993 digest
[18] = (l
>> 16) & 0xff;
1994 digest
[28] = (l
>> 8) & 0xff;
1995 digest
[ 8] = (l
>> 0) & 0xff;
1997 l
= itoa64_to_int (buf
[36]) << 0;
1998 l
|= itoa64_to_int (buf
[37]) << 6;
1999 l
|= itoa64_to_int (buf
[38]) << 12;
2000 l
|= itoa64_to_int (buf
[39]) << 18;
2002 digest
[ 9] = (l
>> 16) & 0xff;
2003 digest
[19] = (l
>> 8) & 0xff;
2004 digest
[29] = (l
>> 0) & 0xff;
2006 l
= itoa64_to_int (buf
[40]) << 0;
2007 l
|= itoa64_to_int (buf
[41]) << 6;
2008 l
|= itoa64_to_int (buf
[42]) << 12;
2010 digest
[31] = (l
>> 8) & 0xff;
2011 digest
[30] = (l
>> 0) & 0xff;
2014 void sha256crypt_encode (unsigned char digest
[32], unsigned char buf
[43])
2018 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2020 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2021 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2022 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2027 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2034 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2041 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2048 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2055 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2062 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2069 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2076 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2083 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2090 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[42] = int_to_itoa64 (l
& 0x3f);
2095 void drupal7_decode (unsigned char digest
[64], unsigned char buf
[44])
2099 l
= itoa64_to_int (buf
[ 0]) << 0;
2100 l
|= itoa64_to_int (buf
[ 1]) << 6;
2101 l
|= itoa64_to_int (buf
[ 2]) << 12;
2102 l
|= itoa64_to_int (buf
[ 3]) << 18;
2104 digest
[ 0] = (l
>> 0) & 0xff;
2105 digest
[ 1] = (l
>> 8) & 0xff;
2106 digest
[ 2] = (l
>> 16) & 0xff;
2108 l
= itoa64_to_int (buf
[ 4]) << 0;
2109 l
|= itoa64_to_int (buf
[ 5]) << 6;
2110 l
|= itoa64_to_int (buf
[ 6]) << 12;
2111 l
|= itoa64_to_int (buf
[ 7]) << 18;
2113 digest
[ 3] = (l
>> 0) & 0xff;
2114 digest
[ 4] = (l
>> 8) & 0xff;
2115 digest
[ 5] = (l
>> 16) & 0xff;
2117 l
= itoa64_to_int (buf
[ 8]) << 0;
2118 l
|= itoa64_to_int (buf
[ 9]) << 6;
2119 l
|= itoa64_to_int (buf
[10]) << 12;
2120 l
|= itoa64_to_int (buf
[11]) << 18;
2122 digest
[ 6] = (l
>> 0) & 0xff;
2123 digest
[ 7] = (l
>> 8) & 0xff;
2124 digest
[ 8] = (l
>> 16) & 0xff;
2126 l
= itoa64_to_int (buf
[12]) << 0;
2127 l
|= itoa64_to_int (buf
[13]) << 6;
2128 l
|= itoa64_to_int (buf
[14]) << 12;
2129 l
|= itoa64_to_int (buf
[15]) << 18;
2131 digest
[ 9] = (l
>> 0) & 0xff;
2132 digest
[10] = (l
>> 8) & 0xff;
2133 digest
[11] = (l
>> 16) & 0xff;
2135 l
= itoa64_to_int (buf
[16]) << 0;
2136 l
|= itoa64_to_int (buf
[17]) << 6;
2137 l
|= itoa64_to_int (buf
[18]) << 12;
2138 l
|= itoa64_to_int (buf
[19]) << 18;
2140 digest
[12] = (l
>> 0) & 0xff;
2141 digest
[13] = (l
>> 8) & 0xff;
2142 digest
[14] = (l
>> 16) & 0xff;
2144 l
= itoa64_to_int (buf
[20]) << 0;
2145 l
|= itoa64_to_int (buf
[21]) << 6;
2146 l
|= itoa64_to_int (buf
[22]) << 12;
2147 l
|= itoa64_to_int (buf
[23]) << 18;
2149 digest
[15] = (l
>> 0) & 0xff;
2150 digest
[16] = (l
>> 8) & 0xff;
2151 digest
[17] = (l
>> 16) & 0xff;
2153 l
= itoa64_to_int (buf
[24]) << 0;
2154 l
|= itoa64_to_int (buf
[25]) << 6;
2155 l
|= itoa64_to_int (buf
[26]) << 12;
2156 l
|= itoa64_to_int (buf
[27]) << 18;
2158 digest
[18] = (l
>> 0) & 0xff;
2159 digest
[19] = (l
>> 8) & 0xff;
2160 digest
[20] = (l
>> 16) & 0xff;
2162 l
= itoa64_to_int (buf
[28]) << 0;
2163 l
|= itoa64_to_int (buf
[29]) << 6;
2164 l
|= itoa64_to_int (buf
[30]) << 12;
2165 l
|= itoa64_to_int (buf
[31]) << 18;
2167 digest
[21] = (l
>> 0) & 0xff;
2168 digest
[22] = (l
>> 8) & 0xff;
2169 digest
[23] = (l
>> 16) & 0xff;
2171 l
= itoa64_to_int (buf
[32]) << 0;
2172 l
|= itoa64_to_int (buf
[33]) << 6;
2173 l
|= itoa64_to_int (buf
[34]) << 12;
2174 l
|= itoa64_to_int (buf
[35]) << 18;
2176 digest
[24] = (l
>> 0) & 0xff;
2177 digest
[25] = (l
>> 8) & 0xff;
2178 digest
[26] = (l
>> 16) & 0xff;
2180 l
= itoa64_to_int (buf
[36]) << 0;
2181 l
|= itoa64_to_int (buf
[37]) << 6;
2182 l
|= itoa64_to_int (buf
[38]) << 12;
2183 l
|= itoa64_to_int (buf
[39]) << 18;
2185 digest
[27] = (l
>> 0) & 0xff;
2186 digest
[28] = (l
>> 8) & 0xff;
2187 digest
[29] = (l
>> 16) & 0xff;
2189 l
= itoa64_to_int (buf
[40]) << 0;
2190 l
|= itoa64_to_int (buf
[41]) << 6;
2191 l
|= itoa64_to_int (buf
[42]) << 12;
2192 l
|= itoa64_to_int (buf
[43]) << 18;
2194 digest
[30] = (l
>> 0) & 0xff;
2195 digest
[31] = (l
>> 8) & 0xff;
2196 digest
[32] = (l
>> 16) & 0xff;
2231 void drupal7_encode (unsigned char digest
[64], unsigned char buf
[43])
2235 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2237 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2238 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2239 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2240 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2242 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2244 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2249 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2251 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[11] = int_to_itoa64 (l
& 0x3f);
2256 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2258 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[15] = int_to_itoa64 (l
& 0x3f);
2263 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2265 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[19] = int_to_itoa64 (l
& 0x3f);
2270 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2272 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[23] = int_to_itoa64 (l
& 0x3f);
2277 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2279 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[27] = int_to_itoa64 (l
& 0x3f);
2284 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2286 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[31] = int_to_itoa64 (l
& 0x3f);
2291 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2293 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[35] = int_to_itoa64 (l
& 0x3f);
2298 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2300 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[39] = int_to_itoa64 (l
& 0x3f);
2305 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2307 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 //buf[43] = int_to_itoa64 (l & 0x3f);
2318 static struct termio savemodes
;
2319 static int havemodes
= 0;
2323 struct termio modmodes
;
2325 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2329 modmodes
= savemodes
;
2330 modmodes
.c_lflag
&= ~ICANON
;
2331 modmodes
.c_cc
[VMIN
] = 1;
2332 modmodes
.c_cc
[VTIME
] = 0;
2334 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2343 FD_SET (fileno (stdin
), &rfds
);
2350 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2352 if (retval
== 0) return 0;
2353 if (retval
== -1) return -1;
2360 if (!havemodes
) return 0;
2362 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2367 static struct termios savemodes
;
2368 static int havemodes
= 0;
2372 struct termios modmodes
;
2374 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2378 modmodes
= savemodes
;
2379 modmodes
.c_lflag
&= ~ICANON
;
2380 modmodes
.c_cc
[VMIN
] = 1;
2381 modmodes
.c_cc
[VTIME
] = 0;
2383 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2392 FD_SET (fileno (stdin
), &rfds
);
2399 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2401 if (retval
== 0) return 0;
2402 if (retval
== -1) return -1;
2409 if (!havemodes
) return 0;
2411 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2416 static DWORD saveMode
= 0;
2420 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2422 GetConsoleMode (stdinHandle
, &saveMode
);
2423 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2430 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2432 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2434 if (rc
== WAIT_TIMEOUT
) return 0;
2435 if (rc
== WAIT_ABANDONED
) return -1;
2436 if (rc
== WAIT_FAILED
) return -1;
2438 // The whole ReadConsoleInput () part is a workaround.
2439 // For some unknown reason, maybe a mingw bug, a random signal
2440 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2441 // Then it wants to read with getche () a keyboard input
2442 // which has never been made.
2444 INPUT_RECORD buf
[100];
2448 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2450 FlushConsoleInputBuffer (stdinHandle
);
2452 for (uint i
= 0; i
< num
; i
++)
2454 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2456 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2458 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2460 return KeyEvent
.uChar
.AsciiChar
;
2468 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2470 SetConsoleMode (stdinHandle
, saveMode
);
2480 #define MSG_ENOMEM "Insufficient memory available"
2482 void *mycalloc (size_t nmemb
, size_t size
)
2484 void *p
= calloc (nmemb
, size
);
2488 log_error ("ERROR: %s", MSG_ENOMEM
);
2496 void *mymalloc (size_t size
)
2498 void *p
= malloc (size
);
2502 log_error ("ERROR: %s", MSG_ENOMEM
);
2507 memset (p
, 0, size
);
2512 void myfree (void *ptr
)
2514 if (ptr
== NULL
) return;
2519 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2521 void *p
= realloc (ptr
, oldsz
+ add
);
2525 log_error ("ERROR: %s", MSG_ENOMEM
);
2530 memset ((char *) p
+ oldsz
, 0, add
);
2535 char *mystrdup (const char *s
)
2537 const size_t len
= strlen (s
);
2539 char *b
= (char *) mymalloc (len
+ 1);
2546 FILE *logfile_open (char *logfile
)
2548 FILE *fp
= fopen (logfile
, "ab");
2558 void logfile_close (FILE *fp
)
2560 if (fp
== stdout
) return;
2565 void logfile_append (const char *fmt
, ...)
2567 if (data
.logfile_disable
== 1) return;
2569 FILE *fp
= logfile_open (data
.logfile
);
2575 vfprintf (fp
, fmt
, ap
);
2586 int logfile_generate_id ()
2588 const int n
= rand ();
2597 char *logfile_generate_topid ()
2599 const int id
= logfile_generate_id ();
2601 char *topid
= (char *) mymalloc (1 + 16 + 1);
2603 sprintf (topid
, "TOP%08x", id
);
2608 char *logfile_generate_subid ()
2610 const int id
= logfile_generate_id ();
2612 char *subid
= (char *) mymalloc (1 + 16 + 1);
2614 sprintf (subid
, "SUB%08x", id
);
2626 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2628 FlushFileBuffers (h
);
2637 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2641 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2645 log_info ("WARN: No NvAPI adapters found");
2655 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2659 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2661 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2663 //can be used to determine if the device by index matches the cuda device by index
2664 //char name[100]; memset (name, 0, sizeof (name));
2665 //hc_NVML_nvmlDeviceGetName (data.hm_dll, nvGPUHandle[i], name, sizeof (name) - 1);
2672 log_info ("WARN: No NVML adapters found");
2681 void hm_close (HM_LIB hm_dll
)
2687 FreeLibrary (hm_dll
);
2694 HM_LIB hm_dll
= NULL
;
2696 if (data
.vendor_id
== VENDOR_ID_AMD
)
2699 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2702 hm_dll
= LoadLibrary ("atiadlxx.dll");
2706 hm_dll
= LoadLibrary ("atiadlxy.dll");
2713 if (data
.vendor_id
== VENDOR_ID_NV
)
2715 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2722 int get_adapters_num_amd (HM_LIB hm_dll
, int *iNumberAdapters
)
2724 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll
, iNumberAdapters
) != ADL_OK
) return -1;
2726 if (iNumberAdapters
== 0)
2728 log_info ("WARN: No ADL adapters found.");
2737 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2739 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2740 ADLODParameters lpOdParameters;
2742 lpOdParameters.iSize = sizeof (ADLODParameters);
2743 size_t plevels_size = 0;
2745 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2747 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2748 __func__, iAdapterIndex,
2749 lpOdParameters.iNumberOfPerformanceLevels,
2750 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2751 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2753 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2755 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2757 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2759 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2761 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2762 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2763 __func__, iAdapterIndex, j,
2764 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2766 myfree (lpOdPerformanceLevels);
2772 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll
, int iNumberAdapters
)
2774 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2776 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2778 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2780 return lpAdapterInfo
;
2785 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2788 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2792 for (uint i = 0; i < num_adl_adapters; i++)
2794 int opencl_bus_num = hm_device[i].busid;
2795 int opencl_dev_num = hm_device[i].devid;
2797 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2805 if (idx >= DEVICES_MAX) return -1;
2810 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2812 for (uint i = 0; i < opencl_num_devices; i++)
2814 cl_device_topology_amd device_topology;
2816 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2818 hm_device[i].busid = device_topology.pcie.bus;
2819 hm_device[i].devid = device_topology.pcie.device;
2824 void hm_sort_adl_adapters_by_busid_devid (uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2826 // basically bubble sort
2828 for (int i
= 0; i
< num_adl_adapters
; i
++)
2830 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2832 // get info of adapter [x]
2834 uint32_t adapter_index_x
= valid_adl_device_list
[j
];
2835 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2837 uint32_t bus_num_x
= info_x
.iBusNumber
;
2838 uint32_t dev_num_x
= info_x
.iDeviceNumber
;
2840 // get info of adapter [y]
2842 uint32_t adapter_index_y
= valid_adl_device_list
[j
+ 1];
2843 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2845 uint32_t bus_num_y
= info_y
.iBusNumber
;
2846 uint32_t dev_num_y
= info_y
.iDeviceNumber
;
2850 if (bus_num_y
< bus_num_x
)
2854 else if (bus_num_y
== bus_num_x
)
2856 if (dev_num_y
< dev_num_x
)
2864 uint32_t temp
= valid_adl_device_list
[j
+ 1];
2866 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2867 valid_adl_device_list
[j
+ 0] = temp
;
2873 uint32_t *hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2875 *num_adl_adapters
= 0;
2877 uint32_t *adl_adapters
= NULL
;
2879 int *bus_numbers
= NULL
;
2880 int *device_numbers
= NULL
;
2882 for (int i
= 0; i
< iNumberAdapters
; i
++)
2884 AdapterInfo info
= lpAdapterInfo
[i
];
2886 if ((info
.strUDID
== NULL
) || (strlen (info
.strUDID
) < 1)) continue;
2889 if (info
.iVendorID
!= 1002) continue;
2891 if (info
.iVendorID
!= 0x1002) continue;
2894 if (info
.iBusNumber
< 0) continue;
2895 if (info
.iDeviceNumber
< 0) continue;
2899 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2901 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2908 if (found
) continue;
2910 // add it to the list
2912 adl_adapters
= (uint32_t *) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2914 adl_adapters
[*num_adl_adapters
] = i
;
2916 // rest is just bookkeeping
2918 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2921 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2922 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2924 (*num_adl_adapters
)++;
2927 myfree (bus_numbers
);
2928 myfree (device_numbers
);
2930 // sort the list by increasing bus id, device id number
2932 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2934 return adl_adapters
;
2937 int hm_check_fanspeed_control (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2939 // loop through all valid devices
2941 for (int i
= 0; i
< num_adl_adapters
; i
++)
2943 uint32_t adapter_index
= valid_adl_device_list
[i
];
2947 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2949 // unfortunately this doesn't work since bus id and dev id are not unique
2950 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2951 // if (opencl_device_index == -1) continue;
2953 int opencl_device_index
= i
;
2955 // if (hm_show_performance_level (hm_dll, info.iAdapterIndex) != 0) return -1;
2957 // get fanspeed info
2959 if (hm_device
[opencl_device_index
].od_version
== 5)
2961 ADLFanSpeedInfo FanSpeedInfo
;
2963 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2965 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2967 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2969 // check read and write capability in fanspeedinfo
2971 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2972 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2974 hm_device
[opencl_device_index
].fan_supported
= 1;
2978 hm_device
[opencl_device_index
].fan_supported
= 0;
2981 else // od_version == 6
2983 ADLOD6FanSpeedInfo faninfo
;
2985 memset (&faninfo
, 0, sizeof (faninfo
));
2987 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2989 // check read capability in fanspeedinfo
2991 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2993 hm_device
[opencl_device_index
].fan_supported
= 1;
2997 hm_device
[opencl_device_index
].fan_supported
= 0;
3005 int hm_get_overdrive_version (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3007 for (int i
= 0; i
< num_adl_adapters
; i
++)
3009 uint32_t adapter_index
= valid_adl_device_list
[i
];
3013 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3015 // get overdrive version
3017 int od_supported
= 0;
3021 if (hc_ADL_Overdrive_Caps (hm_dll
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3023 // store the overdrive version in hm_device
3025 // unfortunately this doesn't work since bus id and dev id are not unique
3026 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3027 // if (opencl_device_index == -1) continue;
3029 int opencl_device_index
= i
;
3031 hm_device
[opencl_device_index
].od_version
= od_version
;
3037 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3039 for (int i
= 0; i
< num_adl_adapters
; i
++)
3041 uint32_t adapter_index
= valid_adl_device_list
[i
];
3045 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3047 // store the iAdapterIndex in hm_device
3049 // unfortunately this doesn't work since bus id and dev id are not unique
3050 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3051 // if (opencl_device_index == -1) continue;
3053 int opencl_device_index
= i
;
3055 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3058 return num_adl_adapters
;
3061 int hm_get_temperature_with_device_id (const uint device_id
)
3063 if (data
.vendor_id
== VENDOR_ID_AMD
)
3067 if (data
.hm_device
[device_id
].od_version
== 5)
3069 ADLTemperature Temperature
;
3071 Temperature
.iSize
= sizeof (ADLTemperature
);
3073 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3075 return Temperature
.iTemperature
/ 1000;
3077 else if (data
.hm_device
[device_id
].od_version
== 6)
3079 int Temperature
= 0;
3081 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3083 return Temperature
/ 1000;
3088 if (data
.vendor_id
== VENDOR_ID_NV
)
3091 int temperature
= 0;
3093 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3099 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3101 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3102 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3103 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3104 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3106 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3108 return pThermalSettings
.sensor
[0].currentTemp
;
3115 int hm_get_fanspeed_with_device_id (const uint device_id
)
3117 if (data
.hm_device
[device_id
].fan_supported
== 1)
3119 if (data
.vendor_id
== VENDOR_ID_AMD
)
3123 if (data
.hm_device
[device_id
].od_version
== 5)
3125 ADLFanSpeedValue lpFanSpeedValue
;
3127 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3129 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3130 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3131 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3133 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3135 return lpFanSpeedValue
.iFanSpeed
;
3137 else // od_version == 6
3139 ADLOD6FanSpeedInfo faninfo
;
3141 memset (&faninfo
, 0, sizeof (faninfo
));
3143 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3145 return faninfo
.iFanSpeedPercent
;
3150 if (data
.vendor_id
== VENDOR_ID_NV
)
3155 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3163 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3173 int hm_get_utilization_with_device_id (const uint device_id
)
3175 if (data
.vendor_id
== VENDOR_ID_AMD
)
3179 ADLPMActivity PMActivity
;
3181 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3183 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3185 return PMActivity
.iActivityPercent
;
3189 if (data
.vendor_id
== VENDOR_ID_NV
)
3192 nvmlUtilization_t utilization
;
3194 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3196 return utilization
.gpu
;
3200 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3202 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3204 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3206 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3213 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3215 if (data
.hm_device
[device_id
].fan_supported
== 1)
3219 if (data
.hm_device
[device_id
].od_version
== 5)
3221 ADLFanSpeedValue lpFanSpeedValue
;
3223 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3225 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3226 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3227 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3228 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3230 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3234 else // od_version == 6
3236 ADLOD6FanSpeedValue fan_speed_value
;
3238 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3240 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3241 fan_speed_value
.iFanSpeed
= fanspeed
;
3243 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3257 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3259 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3261 if (css_cnt
> SP_PW_MAX
)
3263 log_error ("ERROR: mask length is too long");
3268 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3270 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3272 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3273 uint cs_len
= css
[css_pos
].cs_len
;
3275 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3277 uint c
= cs_buf
[cs_pos
] & 0xff;
3284 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3286 cs_t
*cs
= &css
[css_cnt
];
3288 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3290 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3292 memset (css_uniq
, 0, css_uniq_sz
);
3296 for (i
= 0; i
< cs
->cs_len
; i
++)
3298 const uint u
= cs
->cs_buf
[i
];
3303 for (i
= 0; i
< in_len
; i
++)
3305 uint u
= in_buf
[i
] & 0xff;
3307 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3309 if (css_uniq
[u
] == 1) continue;
3313 cs
->cs_buf
[cs
->cs_len
] = u
;
3321 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3325 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3327 uint p0
= in_buf
[in_pos
] & 0xff;
3329 if (interpret
== 1 && p0
== '?')
3333 if (in_pos
== in_len
) break;
3335 uint p1
= in_buf
[in_pos
] & 0xff;
3339 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3341 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3343 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3345 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3347 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3349 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3351 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3352 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3354 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3355 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3357 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3358 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3360 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3361 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3363 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3365 default: log_error ("Syntax error: %s", in_buf
);
3371 if (data
.hex_charset
)
3375 if (in_pos
== in_len
)
3377 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3382 uint p1
= in_buf
[in_pos
] & 0xff;
3384 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3386 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3393 chr
= hex_convert (p1
) << 0;
3394 chr
|= hex_convert (p0
) << 4;
3396 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3402 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3408 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3412 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3414 sum
*= css
[css_pos
].cs_len
;
3420 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3422 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3427 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3429 char p0
= mask_buf
[mask_pos
];
3435 if (mask_pos
== mask_len
) break;
3437 char p1
= mask_buf
[mask_pos
];
3443 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3445 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3447 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3449 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3451 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3453 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3455 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3456 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3458 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3459 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3461 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3462 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3464 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3465 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3467 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3469 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3475 if (data
.hex_charset
)
3479 // if there is no 2nd hex character, show an error:
3481 if (mask_pos
== mask_len
)
3483 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3488 char p1
= mask_buf
[mask_pos
];
3490 // if they are not valid hex character, show an error:
3492 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3494 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3501 chr
|= hex_convert (p1
) << 0;
3502 chr
|= hex_convert (p0
) << 4;
3504 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3517 log_error ("ERROR: invalid mask length (0)");
3527 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3529 for (int i
= 0; i
< css_cnt
; i
++)
3531 uint len
= css
[i
].cs_len
;
3532 uint64_t next
= val
/ len
;
3533 uint pos
= val
% len
;
3534 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3539 void mp_cut_at (char *mask
, uint max
)
3543 uint mask_len
= strlen (mask
);
3545 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3547 if (mask
[i
] == '?') i
++;
3553 void mp_setup_sys (cs_t
*mp_sys
)
3557 uint donec
[CHARSIZ
];
3559 memset (donec
, 0, sizeof (donec
));
3561 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3562 mp_sys
[0].cs_buf
[pos
++] = chr
;
3563 mp_sys
[0].cs_len
= pos
; }
3565 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3566 mp_sys
[1].cs_buf
[pos
++] = chr
;
3567 mp_sys
[1].cs_len
= pos
; }
3569 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3570 mp_sys
[2].cs_buf
[pos
++] = chr
;
3571 mp_sys
[2].cs_len
= pos
; }
3573 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3574 mp_sys
[3].cs_buf
[pos
++] = chr
;
3575 mp_sys
[3].cs_len
= pos
; }
3577 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3578 mp_sys
[4].cs_len
= pos
; }
3580 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3581 mp_sys
[5].cs_len
= pos
; }
3584 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3586 FILE *fp
= fopen (buf
, "rb");
3588 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3590 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3596 memset (mp_file
, 0, sizeof (mp_file
));
3598 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3602 len
= in_superchop (mp_file
);
3606 log_info ("WARNING: charset file corrupted");
3608 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3612 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3617 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3619 mp_usr
[index
].cs_len
= 0;
3621 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3624 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3626 char *new_mask_buf
= (char *) mymalloc (256);
3632 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3634 if (css_pos
== len
) break;
3636 char p0
= mask_buf
[mask_pos
];
3638 new_mask_buf
[mask_pos
] = p0
;
3644 if (mask_pos
== mask_len
) break;
3646 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3650 if (data
.hex_charset
)
3654 if (mask_pos
== mask_len
)
3656 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3661 char p1
= mask_buf
[mask_pos
];
3663 // if they are not valid hex character, show an error:
3665 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3667 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3672 new_mask_buf
[mask_pos
] = p1
;
3677 if (css_pos
== len
) return (new_mask_buf
);
3679 myfree (new_mask_buf
);
3688 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3694 for (i
= start
; i
< stop
; i
++)
3696 sum
*= root_css_buf
[i
].cs_len
;
3702 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3706 cs_t
*cs
= &root_css_buf
[start
];
3710 for (i
= start
; i
< stop
; i
++)
3712 const uint64_t m
= v
% cs
->cs_len
;
3713 const uint64_t d
= v
/ cs
->cs_len
;
3717 const uint k
= cs
->cs_buf
[m
];
3719 pw_buf
[i
- start
] = (char) k
;
3721 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3725 int sp_comp_val (const void *p1
, const void *p2
)
3727 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3728 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3730 return b2
->val
- b1
->val
;
3733 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3740 * Initialize hcstats
3743 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3745 uint64_t *root_stats_ptr
= root_stats_buf
;
3747 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3749 for (i
= 0; i
< SP_PW_MAX
; i
++)
3751 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3753 root_stats_ptr
+= CHARSIZ
;
3756 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3758 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3760 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3762 for (i
= 0; i
< SP_PW_MAX
; i
++)
3764 for (j
= 0; j
< CHARSIZ
; j
++)
3766 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3768 markov_stats_ptr
+= CHARSIZ
;
3778 char hcstat_tmp
[256];
3780 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3782 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3784 hcstat
= hcstat_tmp
;
3787 FILE *fd
= fopen (hcstat
, "rb");
3791 log_error ("%s: %s", hcstat
, strerror (errno
));
3796 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3798 log_error ("%s: Could not load data", hcstat
);
3803 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3805 log_error ("%s: Could not load data", hcstat
);
3813 * Markov modifier of hcstat_table on user request
3818 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3819 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3824 /* Add all stats to first position */
3826 for (i
= 1; i
< SP_PW_MAX
; i
++)
3828 uint64_t *out
= root_stats_buf_by_pos
[0];
3829 uint64_t *in
= root_stats_buf_by_pos
[i
];
3831 for (j
= 0; j
< CHARSIZ
; j
++)
3837 for (i
= 1; i
< SP_PW_MAX
; i
++)
3839 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3840 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3842 for (j
= 0; j
< CHARSIZ
; j
++)
3844 for (k
= 0; k
< CHARSIZ
; k
++)
3851 /* copy them to all pw_positions */
3853 for (i
= 1; i
< SP_PW_MAX
; i
++)
3855 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3858 for (i
= 1; i
< SP_PW_MAX
; i
++)
3860 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3868 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3870 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3872 for (i
= 0; i
< SP_PW_MAX
; i
++)
3874 root_table_buf_by_pos
[i
] = root_table_ptr
;
3876 root_table_ptr
+= CHARSIZ
;
3879 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3881 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3883 for (i
= 0; i
< SP_PW_MAX
; i
++)
3885 for (j
= 0; j
< CHARSIZ
; j
++)
3887 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3889 markov_table_ptr
+= CHARSIZ
;
3894 * Convert hcstat to tables
3897 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3899 uint key
= i
% CHARSIZ
;
3901 root_table_buf
[i
].key
= key
;
3902 root_table_buf
[i
].val
= root_stats_buf
[i
];
3905 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3907 uint key
= i
% CHARSIZ
;
3909 markov_table_buf
[i
].key
= key
;
3910 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3913 myfree (root_stats_buf
);
3914 myfree (markov_stats_buf
);
3920 for (i
= 0; i
< SP_PW_MAX
; i
++)
3922 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3925 for (i
= 0; i
< SP_PW_MAX
; i
++)
3927 for (j
= 0; j
< CHARSIZ
; j
++)
3929 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3934 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3937 * Convert tables to css
3940 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3942 uint pw_pos
= i
/ CHARSIZ
;
3944 cs_t
*cs
= &root_css_buf
[pw_pos
];
3946 if (cs
->cs_len
== threshold
) continue;
3948 uint key
= root_table_buf
[i
].key
;
3950 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3952 cs
->cs_buf
[cs
->cs_len
] = key
;
3958 * Convert table to css
3961 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3963 uint c
= i
/ CHARSIZ
;
3965 cs_t
*cs
= &markov_css_buf
[c
];
3967 if (cs
->cs_len
== threshold
) continue;
3969 uint pw_pos
= c
/ CHARSIZ
;
3971 uint key
= markov_table_buf
[i
].key
;
3973 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3975 cs
->cs_buf
[cs
->cs_len
] = key
;
3981 for (uint i = 0; i < 8; i++)
3983 for (uint j = 0x20; j < 0x80; j++)
3985 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
3987 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
3989 for (uint k = 0; k < 10; k++)
3991 printf (" %u\n", ptr->cs_buf[k]);
3998 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4000 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4002 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4012 for (uint j
= 1; j
< CHARSIZ
; j
++)
4022 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4024 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4026 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4028 out
+= CHARSIZ
* CHARSIZ
;
4029 in
+= CHARSIZ
* CHARSIZ
;
4031 for (uint j
= 0; j
< CHARSIZ
; j
++)
4038 for (uint k
= 1; k
< CHARSIZ
; k
++)
4050 * mixed shared functions
4053 void dump_hex (const char *s
, size_t size
)
4057 for (i
= 0; i
< size
; i
++)
4059 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4065 void usage_mini_print (const char *progname
)
4067 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4070 void usage_big_print (const char *progname
)
4072 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4075 char *get_exec_path ()
4077 int exec_path_len
= 1024;
4079 char *exec_path
= (char *) mymalloc (exec_path_len
);
4085 sprintf (tmp
, "/proc/%d/exe", getpid ());
4087 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4093 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4102 char *get_install_dir (const char *progname
)
4104 char *install_dir
= mystrdup (progname
);
4105 char *last_slash
= NULL
;
4107 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4111 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4117 install_dir
[0] = '.';
4121 return (install_dir
);
4124 char *get_profile_dir (const char *homedir
)
4126 #define DOT_HASHCAT ".hashcat"
4128 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4130 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4135 char *get_session_dir (const char *profile_dir
)
4137 #define SESSIONS_FOLDER "sessions"
4139 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4141 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4146 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4150 FILE *fd
= fopen (file
, "rb");
4154 log_error ("%s: %s", file
, strerror (errno
));
4159 #define MAX_KEY_SIZE (1024 * 1024)
4161 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4163 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4167 for (int fpos
= 0; fpos
< nread
; fpos
++)
4169 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4171 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4172 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4173 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4174 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4176 if (kpos
>= 64) kpos
= 0;
4184 void set_cpu_affinity (char *cpu_affinity
)
4187 DWORD_PTR aff_mask
= 0;
4198 char *devices
= strdup (cpu_affinity
);
4200 char *next
= strtok (devices
, ",");
4204 uint cpu_id
= atoi (next
);
4221 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4227 aff_mask
|= 1 << (cpu_id
- 1);
4231 CPU_SET ((cpu_id
- 1), &cpuset
);
4234 } while ((next
= strtok (NULL
, ",")) != NULL
);
4240 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4241 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4245 pthread_t thread
= pthread_self ();
4246 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4250 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4252 char *element
, *end
;
4254 end
= (char *) base
+ nmemb
* size
;
4256 for (element
= (char *) base
; element
< end
; element
+= size
)
4257 if (!compar (element
, key
))
4263 int sort_by_salt (const void *v1
, const void *v2
)
4265 const salt_t
*s1
= (const salt_t
*) v1
;
4266 const salt_t
*s2
= (const salt_t
*) v2
;
4268 const int res1
= s1
->salt_len
- s2
->salt_len
;
4270 if (res1
!= 0) return (res1
);
4272 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4274 if (res2
!= 0) return (res2
);
4282 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4283 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4290 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4291 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4297 int sort_by_salt_buf (const void *v1
, const void *v2
)
4299 const pot_t
*p1
= (const pot_t
*) v1
;
4300 const pot_t
*p2
= (const pot_t
*) v2
;
4302 const hash_t
*h1
= &p1
->hash
;
4303 const hash_t
*h2
= &p2
->hash
;
4305 const salt_t
*s1
= h1
->salt
;
4306 const salt_t
*s2
= h2
->salt
;
4312 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4313 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4319 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4321 const hash_t
*h1
= (const hash_t
*) v1
;
4322 const hash_t
*h2
= (const hash_t
*) v2
;
4324 const salt_t
*s1
= h1
->salt
;
4325 const salt_t
*s2
= h2
->salt
;
4327 // testphase: this should work
4332 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4333 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4336 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4337 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4338 if (s1->salt_len > s2->salt_len) return ( 1);
4339 if (s1->salt_len < s2->salt_len) return (-1);
4341 uint n = s1->salt_len;
4345 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4346 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4353 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4355 const hash_t
*h1
= (const hash_t
*) v1
;
4356 const hash_t
*h2
= (const hash_t
*) v2
;
4358 const salt_t
*s1
= h1
->salt
;
4359 const salt_t
*s2
= h2
->salt
;
4361 // 12 - 2 (since last 2 uints contain the digest)
4366 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4367 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4373 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4375 const hash_t
*h1
= (const hash_t
*) v1
;
4376 const hash_t
*h2
= (const hash_t
*) v2
;
4378 const void *d1
= h1
->digest
;
4379 const void *d2
= h2
->digest
;
4381 return data
.sort_by_digest (d1
, d2
);
4384 int sort_by_hash (const void *v1
, const void *v2
)
4386 const hash_t
*h1
= (const hash_t
*) v1
;
4387 const hash_t
*h2
= (const hash_t
*) v2
;
4391 const salt_t
*s1
= h1
->salt
;
4392 const salt_t
*s2
= h2
->salt
;
4394 int res
= sort_by_salt (s1
, s2
);
4396 if (res
!= 0) return (res
);
4399 const void *d1
= h1
->digest
;
4400 const void *d2
= h2
->digest
;
4402 return data
.sort_by_digest (d1
, d2
);
4405 int sort_by_pot (const void *v1
, const void *v2
)
4407 const pot_t
*p1
= (const pot_t
*) v1
;
4408 const pot_t
*p2
= (const pot_t
*) v2
;
4410 const hash_t
*h1
= &p1
->hash
;
4411 const hash_t
*h2
= &p2
->hash
;
4413 return sort_by_hash (h1
, h2
);
4416 int sort_by_mtime (const void *p1
, const void *p2
)
4418 const char **f1
= (const char **) p1
;
4419 const char **f2
= (const char **) p2
;
4421 struct stat s1
; stat (*f1
, &s1
);
4422 struct stat s2
; stat (*f2
, &s2
);
4424 return s2
.st_mtime
- s1
.st_mtime
;
4427 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4429 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4430 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4432 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4435 int sort_by_gpu_rule (const void *p1
, const void *p2
)
4437 const gpu_rule_t
*r1
= (const gpu_rule_t
*) p1
;
4438 const gpu_rule_t
*r2
= (const gpu_rule_t
*) p2
;
4440 return memcmp (r1
, r2
, sizeof (gpu_rule_t
));
4443 int sort_by_stringptr (const void *p1
, const void *p2
)
4445 const char **s1
= (const char **) p1
;
4446 const char **s2
= (const char **) p2
;
4448 return strcmp (*s1
, *s2
);
4451 int sort_by_dictstat (const void *s1
, const void *s2
)
4453 dictstat_t
*d1
= (dictstat_t
*) s1
;
4454 dictstat_t
*d2
= (dictstat_t
*) s2
;
4457 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4459 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4462 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4465 int sort_by_bitmap (const void *p1
, const void *p2
)
4467 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4468 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4470 return b1
->collisions
- b2
->collisions
;
4473 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4475 const uint32_t *d1
= (const uint32_t *) v1
;
4476 const uint32_t *d2
= (const uint32_t *) v2
;
4482 if (d1
[n
] > d2
[n
]) return ( 1);
4483 if (d1
[n
] < d2
[n
]) return (-1);
4489 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4491 const uint32_t *d1
= (const uint32_t *) v1
;
4492 const uint32_t *d2
= (const uint32_t *) v2
;
4498 if (d1
[n
] > d2
[n
]) return ( 1);
4499 if (d1
[n
] < d2
[n
]) return (-1);
4505 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4507 const uint32_t *d1
= (const uint32_t *) v1
;
4508 const uint32_t *d2
= (const uint32_t *) v2
;
4514 if (d1
[n
] > d2
[n
]) return ( 1);
4515 if (d1
[n
] < d2
[n
]) return (-1);
4521 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4523 const uint32_t *d1
= (const uint32_t *) v1
;
4524 const uint32_t *d2
= (const uint32_t *) v2
;
4530 if (d1
[n
] > d2
[n
]) return ( 1);
4531 if (d1
[n
] < d2
[n
]) return (-1);
4537 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4539 const uint32_t *d1
= (const uint32_t *) v1
;
4540 const uint32_t *d2
= (const uint32_t *) v2
;
4546 if (d1
[n
] > d2
[n
]) return ( 1);
4547 if (d1
[n
] < d2
[n
]) return (-1);
4553 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4555 const uint32_t *d1
= (const uint32_t *) v1
;
4556 const uint32_t *d2
= (const uint32_t *) v2
;
4562 if (d1
[n
] > d2
[n
]) return ( 1);
4563 if (d1
[n
] < d2
[n
]) return (-1);
4569 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4571 const uint32_t *d1
= (const uint32_t *) v1
;
4572 const uint32_t *d2
= (const uint32_t *) v2
;
4578 if (d1
[n
] > d2
[n
]) return ( 1);
4579 if (d1
[n
] < d2
[n
]) return (-1);
4585 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4587 const uint32_t *d1
= (const uint32_t *) v1
;
4588 const uint32_t *d2
= (const uint32_t *) v2
;
4594 if (d1
[n
] > d2
[n
]) return ( 1);
4595 if (d1
[n
] < d2
[n
]) return (-1);
4601 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4603 const uint64_t *d1
= (const uint64_t *) v1
;
4604 const uint64_t *d2
= (const uint64_t *) v2
;
4610 if (d1
[n
] > d2
[n
]) return ( 1);
4611 if (d1
[n
] < d2
[n
]) return (-1);
4617 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4619 const uint64_t *d1
= (const uint64_t *) v1
;
4620 const uint64_t *d2
= (const uint64_t *) v2
;
4626 if (d1
[n
] > d2
[n
]) return ( 1);
4627 if (d1
[n
] < d2
[n
]) return (-1);
4633 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4635 const uint64_t *d1
= (const uint64_t *) v1
;
4636 const uint64_t *d2
= (const uint64_t *) v2
;
4642 if (d1
[n
] > d2
[n
]) return ( 1);
4643 if (d1
[n
] < d2
[n
]) return (-1);
4649 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4651 const uint32_t *d1
= (const uint32_t *) v1
;
4652 const uint32_t *d2
= (const uint32_t *) v2
;
4654 const uint dgst_pos0
= data
.dgst_pos0
;
4655 const uint dgst_pos1
= data
.dgst_pos1
;
4656 const uint dgst_pos2
= data
.dgst_pos2
;
4657 const uint dgst_pos3
= data
.dgst_pos3
;
4659 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4660 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4661 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4662 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4663 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4664 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4665 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4666 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4671 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
)
4673 uint outfile_autohex
= data
.outfile_autohex
;
4675 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4677 FILE *debug_fp
= NULL
;
4679 if (debug_file
!= NULL
)
4681 debug_fp
= fopen (debug_file
, "ab");
4688 if (debug_fp
== NULL
)
4690 log_info ("WARNING: Could not open debug-file for writing");
4694 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4696 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4698 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4701 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4703 if (debug_mode
== 4)
4705 fputc (':', debug_fp
);
4707 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4710 fputc ('\n', debug_fp
);
4712 if (debug_file
!= NULL
) fclose (debug_fp
);
4716 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4718 int needs_hexify
= 0;
4720 if (outfile_autohex
== 1)
4722 for (uint i
= 0; i
< plain_len
; i
++)
4724 if (plain_ptr
[i
] < 0x20)
4731 if (plain_ptr
[i
] > 0x7f)
4740 if (needs_hexify
== 1)
4742 fprintf (fp
, "$HEX[");
4744 for (uint i
= 0; i
< plain_len
; i
++)
4746 fprintf (fp
, "%02x", plain_ptr
[i
]);
4753 fwrite (plain_ptr
, plain_len
, 1, fp
);
4757 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
)
4759 uint outfile_format
= data
.outfile_format
;
4761 char separator
= data
.separator
;
4763 if (outfile_format
& OUTFILE_FMT_HASH
)
4765 fprintf (out_fp
, "%s", out_buf
);
4767 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4769 fputc (separator
, out_fp
);
4772 else if (data
.username
)
4774 if (username
!= NULL
)
4776 for (uint i
= 0; i
< user_len
; i
++)
4778 fprintf (out_fp
, "%c", username
[i
]);
4781 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4783 fputc (separator
, out_fp
);
4788 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4790 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4792 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4794 fputc (separator
, out_fp
);
4798 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4800 for (uint i
= 0; i
< plain_len
; i
++)
4802 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4805 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4807 fputc (separator
, out_fp
);
4811 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4814 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4819 fprintf (out_fp
, "%lu", crackpos
);
4821 fprintf (out_fp
, "%llu", crackpos
);
4826 fputc ('\n', out_fp
);
4829 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
)
4833 pot_key
.hash
.salt
= hashes_buf
->salt
;
4834 pot_key
.hash
.digest
= hashes_buf
->digest
;
4836 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4842 input_buf
[input_len
] = 0;
4845 unsigned char *username
= NULL
;
4850 user_t
*user
= hashes_buf
->hash_info
->user
;
4854 username
= (unsigned char *) (user
->user_name
);
4856 user_len
= user
->user_len
;
4860 // do output the line
4861 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4865 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4866 #define LM_MASKED_PLAIN "[notfound]"
4868 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
)
4874 pot_left_key
.hash
.salt
= hash_left
->salt
;
4875 pot_left_key
.hash
.digest
= hash_left
->digest
;
4877 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4881 uint weak_hash_found
= 0;
4883 pot_t pot_right_key
;
4885 pot_right_key
.hash
.salt
= hash_right
->salt
;
4886 pot_right_key
.hash
.digest
= hash_right
->digest
;
4888 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4890 if (pot_right_ptr
== NULL
)
4892 // special case, if "weak hash"
4894 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4896 weak_hash_found
= 1;
4898 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4900 // in theory this is not needed, but we are paranoia:
4902 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4903 pot_right_ptr
->plain_len
= 0;
4907 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4909 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
4914 // at least one half was found:
4918 input_buf
[input_len
] = 0;
4922 unsigned char *username
= NULL
;
4927 user_t
*user
= hash_left
->hash_info
->user
;
4931 username
= (unsigned char *) (user
->user_name
);
4933 user_len
= user
->user_len
;
4937 // mask the part which was not found
4939 uint left_part_masked
= 0;
4940 uint right_part_masked
= 0;
4942 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4944 if (pot_left_ptr
== NULL
)
4946 left_part_masked
= 1;
4948 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4950 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4952 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4953 pot_left_ptr
->plain_len
= mask_plain_len
;
4956 if (pot_right_ptr
== NULL
)
4958 right_part_masked
= 1;
4960 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4962 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4964 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4965 pot_right_ptr
->plain_len
= mask_plain_len
;
4968 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4972 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4974 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4976 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4978 // do output the line
4980 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4982 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4984 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4985 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4988 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
)
4992 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4994 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4996 if (pot_ptr
== NULL
)
5000 input_buf
[input_len
] = 0;
5002 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5006 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
)
5012 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5014 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5018 pot_t pot_right_key
;
5020 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5022 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5024 uint weak_hash_found
= 0;
5026 if (pot_right_ptr
== NULL
)
5028 // special case, if "weak hash"
5030 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5032 weak_hash_found
= 1;
5034 // we just need that pot_right_ptr is not a NULL pointer
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5040 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5042 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5047 // ... at least one part was not cracked
5051 input_buf
[input_len
] = 0;
5053 // only show the hash part which is still not cracked
5055 uint user_len
= input_len
- 32;
5057 char hash_output
[user_len
+ 33];
5059 memset (hash_output
, 0, sizeof (hash_output
));
5061 memcpy (hash_output
, input_buf
, input_len
);
5063 if (pot_left_ptr
!= NULL
)
5065 // only show right part (because left part was already found)
5067 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5069 hash_output
[user_len
+ 16] = 0;
5072 if (pot_right_ptr
!= NULL
)
5074 // only show left part (because right part was already found)
5076 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5078 hash_output
[user_len
+ 16] = 0;
5081 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5083 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5086 uint
devices_to_devicemask (char *gpu_devices
)
5088 uint gpu_devicemask
= 0;
5092 char *devices
= strdup (gpu_devices
);
5094 char *next
= strtok (devices
, ",");
5098 uint gpu_id
= atoi (next
);
5100 if (gpu_id
< 1 || gpu_id
> 8)
5102 log_error ("ERROR: invalid gpu_id %u specified", gpu_id
);
5107 gpu_devicemask
|= 1 << (gpu_id
- 1);
5109 } while ((next
= strtok (NULL
, ",")) != NULL
);
5114 return gpu_devicemask
;
5117 uint
get_random_num (uint min
, uint max
)
5119 if (min
== max
) return (min
);
5121 return (uint
) ((rand () % (max
- min
)) + min
);
5124 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5126 uint32_t quotient
= dividend
/ divisor
;
5128 if (dividend
% divisor
) quotient
++;
5133 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5135 uint64_t quotient
= dividend
/ divisor
;
5137 if (dividend
% divisor
) quotient
++;
5142 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5144 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5145 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5147 if (tm
->tm_year
- 70)
5149 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5150 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5152 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5154 else if (tm
->tm_yday
)
5156 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5157 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5159 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5161 else if (tm
->tm_hour
)
5163 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5164 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5166 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5168 else if (tm
->tm_min
)
5170 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5171 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5173 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5177 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5179 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5183 void format_speed_display (float val
, char *buf
, size_t len
)
5194 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5205 /* generate output */
5209 snprintf (buf
, len
- 1, "%.0f ", val
);
5213 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5217 void lowercase (char *buf
, int len
)
5219 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5222 void uppercase (char *buf
, int len
)
5224 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5227 int fgetl (FILE *fp
, char *line_buf
)
5233 const int c
= fgetc (fp
);
5235 if (c
== EOF
) break;
5237 line_buf
[line_len
] = (char) c
;
5241 if (line_len
== BUFSIZ
) line_len
--;
5243 if (c
== '\n') break;
5246 if (line_len
== 0) return 0;
5248 if (line_buf
[line_len
- 1] == '\n')
5252 line_buf
[line_len
] = 0;
5255 if (line_len
== 0) return 0;
5257 if (line_buf
[line_len
- 1] == '\r')
5261 line_buf
[line_len
] = 0;
5267 int in_superchop (char *buf
)
5269 int len
= strlen (buf
);
5273 if (buf
[len
- 1] == '\n')
5280 if (buf
[len
- 1] == '\r')
5295 char **scan_directory (const char *path
)
5297 char *tmp_path
= mystrdup (path
);
5299 size_t tmp_path_len
= strlen (tmp_path
);
5301 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5303 tmp_path
[tmp_path_len
- 1] = 0;
5305 tmp_path_len
= strlen (tmp_path
);
5308 char **files
= NULL
;
5314 if ((d
= opendir (tmp_path
)) != NULL
)
5318 while ((de
= readdir (d
)) != NULL
)
5320 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5322 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5324 char *path_file
= (char *) mymalloc (path_size
+ 1);
5326 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5328 path_file
[path_size
] = 0;
5332 if ((d_test
= opendir (path_file
)) != NULL
)
5340 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5344 files
[num_files
- 1] = path_file
;
5350 else if (errno
== ENOTDIR
)
5352 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5356 files
[num_files
- 1] = mystrdup (path
);
5359 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5363 files
[num_files
- 1] = NULL
;
5370 int count_dictionaries (char **dictionary_files
)
5372 if (dictionary_files
== NULL
) return 0;
5376 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5384 char *stroptitype (const uint opti_type
)
5388 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5389 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5390 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5391 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5392 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5393 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5394 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5395 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5396 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5397 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5398 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5399 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5400 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5401 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5407 char *strparser (const uint parser_status
)
5409 switch (parser_status
)
5411 case PARSER_OK
: return ((char *) PA_000
); break;
5412 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5413 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5414 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5415 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5416 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5417 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5418 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5419 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5420 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5421 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5422 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5423 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5424 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5425 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5426 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5427 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5430 return ((char *) PA_255
);
5433 char *strhashtype (const uint hash_mode
)
5437 case 0: return ((char *) HT_00000
); break;
5438 case 10: return ((char *) HT_00010
); break;
5439 case 11: return ((char *) HT_00011
); break;
5440 case 12: return ((char *) HT_00012
); break;
5441 case 20: return ((char *) HT_00020
); break;
5442 case 21: return ((char *) HT_00021
); break;
5443 case 22: return ((char *) HT_00022
); break;
5444 case 23: return ((char *) HT_00023
); break;
5445 case 30: return ((char *) HT_00030
); break;
5446 case 40: return ((char *) HT_00040
); break;
5447 case 50: return ((char *) HT_00050
); break;
5448 case 60: return ((char *) HT_00060
); break;
5449 case 100: return ((char *) HT_00100
); break;
5450 case 101: return ((char *) HT_00101
); break;
5451 case 110: return ((char *) HT_00110
); break;
5452 case 111: return ((char *) HT_00111
); break;
5453 case 112: return ((char *) HT_00112
); break;
5454 case 120: return ((char *) HT_00120
); break;
5455 case 121: return ((char *) HT_00121
); break;
5456 case 122: return ((char *) HT_00122
); break;
5457 case 124: return ((char *) HT_00124
); break;
5458 case 130: return ((char *) HT_00130
); break;
5459 case 131: return ((char *) HT_00131
); break;
5460 case 132: return ((char *) HT_00132
); break;
5461 case 133: return ((char *) HT_00133
); break;
5462 case 140: return ((char *) HT_00140
); break;
5463 case 141: return ((char *) HT_00141
); break;
5464 case 150: return ((char *) HT_00150
); break;
5465 case 160: return ((char *) HT_00160
); break;
5466 case 190: return ((char *) HT_00190
); break;
5467 case 200: return ((char *) HT_00200
); break;
5468 case 300: return ((char *) HT_00300
); break;
5469 case 400: return ((char *) HT_00400
); break;
5470 case 500: return ((char *) HT_00500
); break;
5471 case 501: return ((char *) HT_00501
); break;
5472 case 900: return ((char *) HT_00900
); break;
5473 case 910: return ((char *) HT_00910
); break;
5474 case 1000: return ((char *) HT_01000
); break;
5475 case 1100: return ((char *) HT_01100
); break;
5476 case 1400: return ((char *) HT_01400
); break;
5477 case 1410: return ((char *) HT_01410
); break;
5478 case 1420: return ((char *) HT_01420
); break;
5479 case 1421: return ((char *) HT_01421
); break;
5480 case 1430: return ((char *) HT_01430
); break;
5481 case 1440: return ((char *) HT_01440
); break;
5482 case 1441: return ((char *) HT_01441
); break;
5483 case 1450: return ((char *) HT_01450
); break;
5484 case 1460: return ((char *) HT_01460
); break;
5485 case 1500: return ((char *) HT_01500
); break;
5486 case 1600: return ((char *) HT_01600
); break;
5487 case 1700: return ((char *) HT_01700
); break;
5488 case 1710: return ((char *) HT_01710
); break;
5489 case 1711: return ((char *) HT_01711
); break;
5490 case 1720: return ((char *) HT_01720
); break;
5491 case 1722: return ((char *) HT_01722
); break;
5492 case 1730: return ((char *) HT_01730
); break;
5493 case 1731: return ((char *) HT_01731
); break;
5494 case 1740: return ((char *) HT_01740
); break;
5495 case 1750: return ((char *) HT_01750
); break;
5496 case 1760: return ((char *) HT_01760
); break;
5497 case 1800: return ((char *) HT_01800
); break;
5498 case 2100: return ((char *) HT_02100
); break;
5499 case 2400: return ((char *) HT_02400
); break;
5500 case 2410: return ((char *) HT_02410
); break;
5501 case 2500: return ((char *) HT_02500
); break;
5502 case 2600: return ((char *) HT_02600
); break;
5503 case 2611: return ((char *) HT_02611
); break;
5504 case 2612: return ((char *) HT_02612
); break;
5505 case 2711: return ((char *) HT_02711
); break;
5506 case 2811: return ((char *) HT_02811
); break;
5507 case 3000: return ((char *) HT_03000
); break;
5508 case 3100: return ((char *) HT_03100
); break;
5509 case 3200: return ((char *) HT_03200
); break;
5510 case 3710: return ((char *) HT_03710
); break;
5511 case 3711: return ((char *) HT_03711
); break;
5512 case 3800: return ((char *) HT_03800
); break;
5513 case 4300: return ((char *) HT_04300
); break;
5514 case 4400: return ((char *) HT_04400
); break;
5515 case 4500: return ((char *) HT_04500
); break;
5516 case 4700: return ((char *) HT_04700
); break;
5517 case 4800: return ((char *) HT_04800
); break;
5518 case 4900: return ((char *) HT_04900
); break;
5519 case 5000: return ((char *) HT_05000
); break;
5520 case 5100: return ((char *) HT_05100
); break;
5521 case 5200: return ((char *) HT_05200
); break;
5522 case 5300: return ((char *) HT_05300
); break;
5523 case 5400: return ((char *) HT_05400
); break;
5524 case 5500: return ((char *) HT_05500
); break;
5525 case 5600: return ((char *) HT_05600
); break;
5526 case 5700: return ((char *) HT_05700
); break;
5527 case 5800: return ((char *) HT_05800
); break;
5528 case 6000: return ((char *) HT_06000
); break;
5529 case 6100: return ((char *) HT_06100
); break;
5530 case 6211: return ((char *) HT_06211
); break;
5531 case 6212: return ((char *) HT_06212
); break;
5532 case 6213: return ((char *) HT_06213
); break;
5533 case 6221: return ((char *) HT_06221
); break;
5534 case 6222: return ((char *) HT_06222
); break;
5535 case 6223: return ((char *) HT_06223
); break;
5536 case 6231: return ((char *) HT_06231
); break;
5537 case 6232: return ((char *) HT_06232
); break;
5538 case 6233: return ((char *) HT_06233
); break;
5539 case 6241: return ((char *) HT_06241
); break;
5540 case 6242: return ((char *) HT_06242
); break;
5541 case 6243: return ((char *) HT_06243
); break;
5542 case 6300: return ((char *) HT_06300
); break;
5543 case 6400: return ((char *) HT_06400
); break;
5544 case 6500: return ((char *) HT_06500
); break;
5545 case 6600: return ((char *) HT_06600
); break;
5546 case 6700: return ((char *) HT_06700
); break;
5547 case 6800: return ((char *) HT_06800
); break;
5548 case 6900: return ((char *) HT_06900
); break;
5549 case 7100: return ((char *) HT_07100
); break;
5550 case 7200: return ((char *) HT_07200
); break;
5551 case 7300: return ((char *) HT_07300
); break;
5552 case 7400: return ((char *) HT_07400
); break;
5553 case 7500: return ((char *) HT_07500
); break;
5554 case 7600: return ((char *) HT_07600
); break;
5555 case 7700: return ((char *) HT_07700
); break;
5556 case 7800: return ((char *) HT_07800
); break;
5557 case 7900: return ((char *) HT_07900
); break;
5558 case 8000: return ((char *) HT_08000
); break;
5559 case 8100: return ((char *) HT_08100
); break;
5560 case 8200: return ((char *) HT_08200
); break;
5561 case 8300: return ((char *) HT_08300
); break;
5562 case 8400: return ((char *) HT_08400
); break;
5563 case 8500: return ((char *) HT_08500
); break;
5564 case 8600: return ((char *) HT_08600
); break;
5565 case 8700: return ((char *) HT_08700
); break;
5566 case 8800: return ((char *) HT_08800
); break;
5567 case 8900: return ((char *) HT_08900
); break;
5568 case 9000: return ((char *) HT_09000
); break;
5569 case 9100: return ((char *) HT_09100
); break;
5570 case 9200: return ((char *) HT_09200
); break;
5571 case 9300: return ((char *) HT_09300
); break;
5572 case 9400: return ((char *) HT_09400
); break;
5573 case 9500: return ((char *) HT_09500
); break;
5574 case 9600: return ((char *) HT_09600
); break;
5575 case 9700: return ((char *) HT_09700
); break;
5576 case 9710: return ((char *) HT_09710
); break;
5577 case 9720: return ((char *) HT_09720
); break;
5578 case 9800: return ((char *) HT_09800
); break;
5579 case 9810: return ((char *) HT_09810
); break;
5580 case 9820: return ((char *) HT_09820
); break;
5581 case 9900: return ((char *) HT_09900
); break;
5582 case 10000: return ((char *) HT_10000
); break;
5583 case 10100: return ((char *) HT_10100
); break;
5584 case 10200: return ((char *) HT_10200
); break;
5585 case 10300: return ((char *) HT_10300
); break;
5586 case 10400: return ((char *) HT_10400
); break;
5587 case 10410: return ((char *) HT_10410
); break;
5588 case 10420: return ((char *) HT_10420
); break;
5589 case 10500: return ((char *) HT_10500
); break;
5590 case 10600: return ((char *) HT_10600
); break;
5591 case 10700: return ((char *) HT_10700
); break;
5592 case 10800: return ((char *) HT_10800
); break;
5593 case 10900: return ((char *) HT_10900
); break;
5594 case 11000: return ((char *) HT_11000
); break;
5595 case 11100: return ((char *) HT_11100
); break;
5596 case 11200: return ((char *) HT_11200
); break;
5597 case 11300: return ((char *) HT_11300
); break;
5598 case 11400: return ((char *) HT_11400
); break;
5599 case 11500: return ((char *) HT_11500
); break;
5600 case 11600: return ((char *) HT_11600
); break;
5601 case 11700: return ((char *) HT_11700
); break;
5602 case 11800: return ((char *) HT_11800
); break;
5603 case 11900: return ((char *) HT_11900
); break;
5604 case 12000: return ((char *) HT_12000
); break;
5605 case 12100: return ((char *) HT_12100
); break;
5606 case 12200: return ((char *) HT_12200
); break;
5607 case 12300: return ((char *) HT_12300
); break;
5608 case 12400: return ((char *) HT_12400
); break;
5609 case 12500: return ((char *) HT_12500
); break;
5610 case 12600: return ((char *) HT_12600
); break;
5611 case 12700: return ((char *) HT_12700
); break;
5612 case 12800: return ((char *) HT_12800
); break;
5615 return ((char *) "Unknown");
5618 char *strstatus (const uint devices_status
)
5620 switch (devices_status
)
5622 case STATUS_INIT
: return ((char *) ST_0000
); break;
5623 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5624 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5625 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5626 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5627 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5628 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5629 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5630 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5631 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5634 return ((char *) "Unknown");
5637 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5639 uint hash_type
= data
.hash_type
;
5640 uint hash_mode
= data
.hash_mode
;
5641 uint salt_type
= data
.salt_type
;
5642 uint opts_type
= data
.opts_type
;
5643 uint opti_type
= data
.opti_type
;
5644 uint dgst_size
= data
.dgst_size
;
5646 char *hashfile
= data
.hashfile
;
5650 uint digest_buf
[64];
5652 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5654 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5656 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5658 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5664 case HASH_TYPE_DESCRYPT
:
5665 FP (digest_buf
[1], digest_buf
[0], tt
);
5668 case HASH_TYPE_DESRACF
:
5669 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5670 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5672 FP (digest_buf
[1], digest_buf
[0], tt
);
5676 FP (digest_buf
[1], digest_buf
[0], tt
);
5679 case HASH_TYPE_NETNTLM
:
5680 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5681 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5682 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5683 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5685 FP (digest_buf
[1], digest_buf
[0], tt
);
5686 FP (digest_buf
[3], digest_buf
[2], tt
);
5689 case HASH_TYPE_BSDICRYPT
:
5690 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5691 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5693 FP (digest_buf
[1], digest_buf
[0], tt
);
5698 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5703 digest_buf
[0] += MD4M_A
;
5704 digest_buf
[1] += MD4M_B
;
5705 digest_buf
[2] += MD4M_C
;
5706 digest_buf
[3] += MD4M_D
;
5710 digest_buf
[0] += MD5M_A
;
5711 digest_buf
[1] += MD5M_B
;
5712 digest_buf
[2] += MD5M_C
;
5713 digest_buf
[3] += MD5M_D
;
5716 case HASH_TYPE_SHA1
:
5717 digest_buf
[0] += SHA1M_A
;
5718 digest_buf
[1] += SHA1M_B
;
5719 digest_buf
[2] += SHA1M_C
;
5720 digest_buf
[3] += SHA1M_D
;
5721 digest_buf
[4] += SHA1M_E
;
5724 case HASH_TYPE_SHA256
:
5725 digest_buf
[0] += SHA256M_A
;
5726 digest_buf
[1] += SHA256M_B
;
5727 digest_buf
[2] += SHA256M_C
;
5728 digest_buf
[3] += SHA256M_D
;
5729 digest_buf
[4] += SHA256M_E
;
5730 digest_buf
[5] += SHA256M_F
;
5731 digest_buf
[6] += SHA256M_G
;
5732 digest_buf
[7] += SHA256M_H
;
5735 case HASH_TYPE_SHA384
:
5736 digest_buf64
[0] += SHA384M_A
;
5737 digest_buf64
[1] += SHA384M_B
;
5738 digest_buf64
[2] += SHA384M_C
;
5739 digest_buf64
[3] += SHA384M_D
;
5740 digest_buf64
[4] += SHA384M_E
;
5741 digest_buf64
[5] += SHA384M_F
;
5742 digest_buf64
[6] += 0;
5743 digest_buf64
[7] += 0;
5746 case HASH_TYPE_SHA512
:
5747 digest_buf64
[0] += SHA512M_A
;
5748 digest_buf64
[1] += SHA512M_B
;
5749 digest_buf64
[2] += SHA512M_C
;
5750 digest_buf64
[3] += SHA512M_D
;
5751 digest_buf64
[4] += SHA512M_E
;
5752 digest_buf64
[5] += SHA512M_F
;
5753 digest_buf64
[6] += SHA512M_G
;
5754 digest_buf64
[7] += SHA512M_H
;
5759 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5761 if (dgst_size
== DGST_SIZE_4_2
)
5763 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5765 else if (dgst_size
== DGST_SIZE_4_4
)
5767 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5769 else if (dgst_size
== DGST_SIZE_4_5
)
5771 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5773 else if (dgst_size
== DGST_SIZE_4_6
)
5775 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5777 else if (dgst_size
== DGST_SIZE_4_8
)
5779 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5781 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5783 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5785 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5787 else if (hash_type
== HASH_TYPE_SHA384
)
5789 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5791 else if (hash_type
== HASH_TYPE_SHA512
)
5793 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5795 else if (hash_type
== HASH_TYPE_GOST
)
5797 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5800 else if (dgst_size
== DGST_SIZE_4_64
)
5802 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5804 else if (dgst_size
== DGST_SIZE_8_25
)
5806 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5810 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5811 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5812 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5818 memset (&salt
, 0, sizeof (salt_t
));
5820 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5822 char *ptr
= (char *) salt
.salt_buf
;
5824 uint len
= salt
.salt_len
;
5826 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5832 case HASH_TYPE_NETNTLM
:
5834 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5835 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5837 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5843 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5845 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5853 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5855 uint max
= salt
.salt_len
/ 4;
5859 for (uint i
= 0; i
< max
; i
++)
5861 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5865 if (opts_type
& OPTS_TYPE_ST_HEX
)
5869 memset (tmp
, 0, sizeof (tmp
));
5871 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5873 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5878 memcpy (ptr
, tmp
, len
);
5881 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5883 memset (ptr
+ len
, 0, memset_size
);
5885 salt
.salt_len
= len
;
5889 // some modes require special encoding
5892 uint out_buf_plain
[256];
5893 uint out_buf_salt
[256];
5897 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5898 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5900 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5902 char *ptr_plain
= (char *) out_buf_plain
;
5903 char *ptr_salt
= (char *) out_buf_salt
;
5905 if (hash_mode
== 22)
5909 memset (username
, 0, sizeof (username
));
5911 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5913 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5915 uint16_t *ptr
= (uint16_t *) digest_buf
;
5917 tmp_buf
[ 0] = sig
[0];
5918 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5919 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5920 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5921 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5922 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5923 tmp_buf
[ 6] = sig
[1];
5924 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5925 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5926 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5927 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5928 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5929 tmp_buf
[12] = sig
[2];
5930 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5931 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5932 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5933 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5934 tmp_buf
[17] = sig
[3];
5935 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5936 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5937 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5938 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5939 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5940 tmp_buf
[23] = sig
[4];
5941 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5942 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5943 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5944 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5945 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5946 tmp_buf
[29] = sig
[5];
5948 snprintf (out_buf
, len
-1, "%s:%s",
5952 else if (hash_mode
== 23)
5954 // do not show the \nskyper\n part in output
5956 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5958 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5960 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5967 else if (hash_mode
== 101)
5969 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5971 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5972 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5973 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5974 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5975 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5977 memcpy (tmp_buf
, digest_buf
, 20);
5979 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5981 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5983 else if (hash_mode
== 111)
5985 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5987 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5988 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5989 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5990 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5991 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5993 memcpy (tmp_buf
, digest_buf
, 20);
5994 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5996 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5998 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6000 else if (hash_mode
== 122)
6002 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6003 (unsigned char *) salt
.salt_buf
,
6010 else if (hash_mode
== 124)
6012 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6013 (unsigned char *) salt
.salt_buf
,
6020 else if (hash_mode
== 131)
6022 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6023 (unsigned char *) salt
.salt_buf
,
6031 else if (hash_mode
== 132)
6033 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6034 (unsigned char *) salt
.salt_buf
,
6041 else if (hash_mode
== 133)
6043 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6045 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6046 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6047 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6048 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6049 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6051 memcpy (tmp_buf
, digest_buf
, 20);
6053 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6055 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6057 else if (hash_mode
== 141)
6059 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6061 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6063 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6065 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6067 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6068 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6069 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6070 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6071 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6073 memcpy (tmp_buf
, digest_buf
, 20);
6075 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6079 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6081 else if (hash_mode
== 400)
6083 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6085 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6086 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6087 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6088 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6090 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6092 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6094 else if (hash_mode
== 500)
6096 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6098 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6099 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6100 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6101 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6103 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6105 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6107 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6111 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6114 else if (hash_mode
== 501)
6116 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6118 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6119 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6121 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6123 else if (hash_mode
== 1421)
6125 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6127 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6143 else if (hash_mode
== 1441)
6145 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6147 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
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]);
6155 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6156 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6157 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6158 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6159 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6160 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6162 memcpy (tmp_buf
, digest_buf
, 32);
6164 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6168 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6170 else if (hash_mode
== 1500)
6172 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6173 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6174 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6175 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6176 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6178 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6180 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6182 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6183 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6185 memcpy (tmp_buf
, digest_buf
, 8);
6187 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6189 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6193 else if (hash_mode
== 1600)
6195 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6197 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6198 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6199 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6200 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6202 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6204 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6206 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6210 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6213 else if (hash_mode
== 1711)
6215 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6217 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6218 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6219 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6220 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6221 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6222 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6223 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6224 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6226 memcpy (tmp_buf
, digest_buf
, 64);
6227 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6229 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6231 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6233 else if (hash_mode
== 1722)
6235 uint
*ptr
= digest_buf
;
6237 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6238 (unsigned char *) salt
.salt_buf
,
6248 else if (hash_mode
== 1731)
6250 uint
*ptr
= digest_buf
;
6252 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6253 (unsigned char *) salt
.salt_buf
,
6263 else if (hash_mode
== 1800)
6267 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6268 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6269 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6270 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6271 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6272 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6273 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6274 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6276 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6278 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6280 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6284 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6287 else if (hash_mode
== 2100)
6291 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6293 salt
.salt_iter
+ 1);
6295 uint signature_len
= strlen (out_buf
);
6297 pos
+= signature_len
;
6298 len
-= signature_len
;
6300 char *salt_ptr
= (char *) salt
.salt_buf
;
6302 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6304 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6305 byte_swap_32 (digest_buf
[0]),
6306 byte_swap_32 (digest_buf
[1]),
6307 byte_swap_32 (digest_buf
[2]),
6308 byte_swap_32 (digest_buf
[3]));
6310 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6312 memcpy (tmp_buf
, digest_buf
, 16);
6314 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6316 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6317 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6318 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6319 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6321 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6322 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6323 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6324 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6326 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6327 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6328 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6329 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6331 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6332 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6333 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6334 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6336 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6337 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6338 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6339 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6343 else if (hash_mode
== 2500)
6345 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6347 wpa_t
*wpa
= &wpas
[salt_pos
];
6351 char *pke_ptr
= (char *) pke
;
6353 for (uint i
= 0; i
< 25; i
++)
6355 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6358 unsigned char mac1
[6];
6359 unsigned char mac2
[6];
6361 memcpy (mac1
, pke_ptr
+ 23, 6);
6362 memcpy (mac2
, pke_ptr
+ 29, 6);
6364 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6365 (char *) salt
.salt_buf
,
6379 else if (hash_mode
== 4400)
6381 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6382 byte_swap_32 (digest_buf
[0]),
6383 byte_swap_32 (digest_buf
[1]),
6384 byte_swap_32 (digest_buf
[2]),
6385 byte_swap_32 (digest_buf
[3]));
6387 else if (hash_mode
== 4700)
6389 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6390 byte_swap_32 (digest_buf
[0]),
6391 byte_swap_32 (digest_buf
[1]),
6392 byte_swap_32 (digest_buf
[2]),
6393 byte_swap_32 (digest_buf
[3]),
6394 byte_swap_32 (digest_buf
[4]));
6396 else if (hash_mode
== 4800)
6398 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6400 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6405 byte_swap_32 (salt
.salt_buf
[0]),
6406 byte_swap_32 (salt
.salt_buf
[1]),
6407 byte_swap_32 (salt
.salt_buf
[2]),
6408 byte_swap_32 (salt
.salt_buf
[3]),
6411 else if (hash_mode
== 4900)
6413 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6414 byte_swap_32 (digest_buf
[0]),
6415 byte_swap_32 (digest_buf
[1]),
6416 byte_swap_32 (digest_buf
[2]),
6417 byte_swap_32 (digest_buf
[3]),
6418 byte_swap_32 (digest_buf
[4]));
6420 else if (hash_mode
== 5100)
6422 snprintf (out_buf
, len
-1, "%08x%08x",
6426 else if (hash_mode
== 5200)
6428 snprintf (out_buf
, len
-1, "%s", hashfile
);
6430 else if (hash_mode
== 5300)
6432 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6434 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6436 int buf_len
= len
-1;
6440 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6442 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6444 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6446 snprintf (out_buf
, buf_len
, ":");
6452 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6460 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6462 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6464 if ((i
== 0) || (i
== 5))
6466 snprintf (out_buf
, buf_len
, ":");
6472 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6480 for (uint i
= 0; i
< 4; i
++)
6484 snprintf (out_buf
, buf_len
, ":");
6490 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6496 else if (hash_mode
== 5400)
6498 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6500 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6502 int buf_len
= len
-1;
6506 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6508 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6510 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6512 snprintf (out_buf
, buf_len
, ":");
6518 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6526 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6528 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6530 if ((i
== 0) || (i
== 5))
6532 snprintf (out_buf
, buf_len
, ":");
6538 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6546 for (uint i
= 0; i
< 5; i
++)
6550 snprintf (out_buf
, buf_len
, ":");
6556 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6562 else if (hash_mode
== 5500)
6564 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6566 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6569 char domain_buf
[64];
6570 char srvchall_buf
[1024];
6571 char clichall_buf
[1024];
6573 memset (user_buf
, 0, sizeof (user_buf
));
6574 memset (domain_buf
, 0, sizeof (domain_buf
));
6575 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6576 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6578 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6580 char *ptr
= (char *) netntlm
->userdomain_buf
;
6582 user_buf
[i
] = ptr
[j
];
6585 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6587 char *ptr
= (char *) netntlm
->userdomain_buf
;
6589 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6592 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6594 char *ptr
= (char *) netntlm
->chall_buf
;
6596 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6599 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6601 char *ptr
= (char *) netntlm
->chall_buf
;
6603 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6606 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6614 byte_swap_32 (salt
.salt_buf_pc
[0]),
6615 byte_swap_32 (salt
.salt_buf_pc
[1]),
6618 else if (hash_mode
== 5600)
6620 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6622 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6625 char domain_buf
[64];
6626 char srvchall_buf
[1024];
6627 char clichall_buf
[1024];
6629 memset (user_buf
, 0, sizeof (user_buf
));
6630 memset (domain_buf
, 0, sizeof (domain_buf
));
6631 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6632 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6634 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6636 char *ptr
= (char *) netntlm
->userdomain_buf
;
6638 user_buf
[i
] = ptr
[j
];
6641 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6643 char *ptr
= (char *) netntlm
->userdomain_buf
;
6645 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6648 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6650 char *ptr
= (char *) netntlm
->chall_buf
;
6652 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6655 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6657 char *ptr
= (char *) netntlm
->chall_buf
;
6659 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6662 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6672 else if (hash_mode
== 5700)
6674 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6676 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6677 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6678 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6679 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6680 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6681 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6682 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6683 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6685 memcpy (tmp_buf
, digest_buf
, 32);
6687 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6691 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6693 else if (hash_mode
== 5800)
6695 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6696 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6697 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6698 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6699 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6701 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6708 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6710 snprintf (out_buf
, len
-1, "%s", hashfile
);
6712 else if (hash_mode
== 6300)
6714 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6716 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6717 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6718 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6719 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6721 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6723 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6725 else if (hash_mode
== 6400)
6727 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6729 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6731 else if (hash_mode
== 6500)
6733 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6735 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6737 else if (hash_mode
== 6600)
6739 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6741 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6743 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6744 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6746 uint buf_len
= len
- 1;
6748 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6751 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6753 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6758 else if (hash_mode
== 6700)
6760 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6762 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6764 else if (hash_mode
== 6800)
6766 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6768 else if (hash_mode
== 7100)
6770 uint
*ptr
= digest_buf
;
6772 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6774 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6778 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6779 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6780 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6781 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6782 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6783 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6784 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6785 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6787 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",
6788 SIGNATURE_SHA512OSX
,
6790 esalt
[ 0], esalt
[ 1],
6791 esalt
[ 2], esalt
[ 3],
6792 esalt
[ 4], esalt
[ 5],
6793 esalt
[ 6], esalt
[ 7],
6801 ptr
[15], ptr
[14]);
6803 else if (hash_mode
== 7200)
6805 uint
*ptr
= digest_buf
;
6807 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6809 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6813 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6815 len_used
= strlen (out_buf
);
6817 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6819 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6821 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6824 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",
6832 ptr
[15], ptr
[14]);
6834 else if (hash_mode
== 7300)
6836 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6838 rakp_t
*rakp
= &rakps
[salt_pos
];
6840 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6842 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6845 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6852 else if (hash_mode
== 7400)
6854 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6856 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6857 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6858 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6859 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6860 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6861 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6862 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6863 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6865 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6867 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6869 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6873 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6876 else if (hash_mode
== 7500)
6878 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6880 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6882 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6883 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6887 char *ptr_data
= data
;
6889 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6891 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6894 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6896 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6901 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6903 (char *) krb5pa
->user
,
6904 (char *) krb5pa
->realm
,
6905 (char *) krb5pa
->salt
,
6908 else if (hash_mode
== 7700)
6910 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6911 (char *) salt
.salt_buf
,
6915 else if (hash_mode
== 7800)
6917 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6918 (char *) salt
.salt_buf
,
6925 else if (hash_mode
== 7900)
6927 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6931 char *tmp
= (char *) salt
.salt_buf_pc
;
6933 ptr_plain
[42] = tmp
[0];
6939 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6941 else if (hash_mode
== 8000)
6943 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6944 (unsigned char *) salt
.salt_buf
,
6954 else if (hash_mode
== 8100)
6956 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6957 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6959 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6960 (unsigned char *) salt
.salt_buf
,
6967 else if (hash_mode
== 8200)
6969 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6971 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6973 char data_buf
[4096];
6975 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6977 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6980 data_buf
[cloudkey
->data_len
* 2] = 0;
6982 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6983 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6984 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6985 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6986 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6987 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6988 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6989 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6991 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6992 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6993 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6994 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6996 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7012 else if (hash_mode
== 8300)
7016 char digest_buf_c
[33];
7018 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
7020 digest_buf_c
[32] = 0;
7024 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7026 char domain_buf_c
[33];
7028 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7030 for (uint i
= 0; i
< salt_pc_len
; i
++)
7032 const char next
= domain_buf_c
[i
];
7034 domain_buf_c
[i
] = '.';
7039 domain_buf_c
[salt_pc_len
] = 0;
7043 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7045 else if (hash_mode
== 8500)
7047 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7049 else if (hash_mode
== 2612)
7051 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7053 (char *) salt
.salt_buf
,
7059 else if (hash_mode
== 3711)
7061 char *salt_ptr
= (char *) salt
.salt_buf
;
7063 salt_ptr
[salt
.salt_len
- 1] = 0;
7065 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7066 SIGNATURE_MEDIAWIKI_B
,
7073 else if (hash_mode
== 8800)
7075 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7077 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7081 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7083 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7088 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7089 SIGNATURE_ANDROIDFDE
,
7090 byte_swap_32 (salt
.salt_buf
[0]),
7091 byte_swap_32 (salt
.salt_buf
[1]),
7092 byte_swap_32 (salt
.salt_buf
[2]),
7093 byte_swap_32 (salt
.salt_buf
[3]),
7094 byte_swap_32 (digest_buf
[0]),
7095 byte_swap_32 (digest_buf
[1]),
7096 byte_swap_32 (digest_buf
[2]),
7097 byte_swap_32 (digest_buf
[3]),
7100 else if (hash_mode
== 8900)
7102 uint N
= salt
.scrypt_N
;
7103 uint r
= salt
.scrypt_r
;
7104 uint p
= salt
.scrypt_p
;
7106 char base64_salt
[32];
7108 memset (base64_salt
, 0, 32);
7110 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7112 memset (tmp_buf
, 0, 46);
7114 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7115 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7116 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7117 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7118 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7119 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7120 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7121 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7122 digest_buf
[8] = 0; // needed for base64_encode ()
7124 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7126 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7134 else if (hash_mode
== 9000)
7136 snprintf (out_buf
, len
-1, "%s", hashfile
);
7138 else if (hash_mode
== 9200)
7142 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7144 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7146 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7150 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7151 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7152 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7153 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7154 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7155 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7156 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7157 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7158 digest_buf
[8] = 0; // needed for base64_encode ()
7161 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7163 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7164 tmp_buf
[43] = 0; // cut it here
7168 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7170 else if (hash_mode
== 9300)
7172 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7173 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7174 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7175 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7176 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7177 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7178 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7179 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7180 digest_buf
[8] = 0; // needed for base64_encode ()
7183 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7185 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7186 tmp_buf
[43] = 0; // cut it here
7188 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7190 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7192 else if (hash_mode
== 9400)
7194 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7196 office2007_t
*office2007
= &office2007s
[salt_pos
];
7198 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7199 SIGNATURE_OFFICE2007
,
7202 office2007
->keySize
,
7208 office2007
->encryptedVerifier
[0],
7209 office2007
->encryptedVerifier
[1],
7210 office2007
->encryptedVerifier
[2],
7211 office2007
->encryptedVerifier
[3],
7212 office2007
->encryptedVerifierHash
[0],
7213 office2007
->encryptedVerifierHash
[1],
7214 office2007
->encryptedVerifierHash
[2],
7215 office2007
->encryptedVerifierHash
[3],
7216 office2007
->encryptedVerifierHash
[4]);
7218 else if (hash_mode
== 9500)
7220 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7222 office2010_t
*office2010
= &office2010s
[salt_pos
];
7224 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,
7230 office2010
->encryptedVerifier
[0],
7231 office2010
->encryptedVerifier
[1],
7232 office2010
->encryptedVerifier
[2],
7233 office2010
->encryptedVerifier
[3],
7234 office2010
->encryptedVerifierHash
[0],
7235 office2010
->encryptedVerifierHash
[1],
7236 office2010
->encryptedVerifierHash
[2],
7237 office2010
->encryptedVerifierHash
[3],
7238 office2010
->encryptedVerifierHash
[4],
7239 office2010
->encryptedVerifierHash
[5],
7240 office2010
->encryptedVerifierHash
[6],
7241 office2010
->encryptedVerifierHash
[7]);
7243 else if (hash_mode
== 9600)
7245 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7247 office2013_t
*office2013
= &office2013s
[salt_pos
];
7249 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,
7255 office2013
->encryptedVerifier
[0],
7256 office2013
->encryptedVerifier
[1],
7257 office2013
->encryptedVerifier
[2],
7258 office2013
->encryptedVerifier
[3],
7259 office2013
->encryptedVerifierHash
[0],
7260 office2013
->encryptedVerifierHash
[1],
7261 office2013
->encryptedVerifierHash
[2],
7262 office2013
->encryptedVerifierHash
[3],
7263 office2013
->encryptedVerifierHash
[4],
7264 office2013
->encryptedVerifierHash
[5],
7265 office2013
->encryptedVerifierHash
[6],
7266 office2013
->encryptedVerifierHash
[7]);
7268 else if (hash_mode
== 9700)
7270 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7272 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7274 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7275 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7276 byte_swap_32 (salt
.salt_buf
[0]),
7277 byte_swap_32 (salt
.salt_buf
[1]),
7278 byte_swap_32 (salt
.salt_buf
[2]),
7279 byte_swap_32 (salt
.salt_buf
[3]),
7280 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7281 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7282 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7283 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7284 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7285 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7286 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7287 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7289 else if (hash_mode
== 9710)
7291 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7293 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7295 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7296 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7297 byte_swap_32 (salt
.salt_buf
[0]),
7298 byte_swap_32 (salt
.salt_buf
[1]),
7299 byte_swap_32 (salt
.salt_buf
[2]),
7300 byte_swap_32 (salt
.salt_buf
[3]),
7301 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7302 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7303 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7304 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7305 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7306 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7307 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7308 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7310 else if (hash_mode
== 9720)
7312 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7314 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7316 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7318 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7319 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7320 byte_swap_32 (salt
.salt_buf
[0]),
7321 byte_swap_32 (salt
.salt_buf
[1]),
7322 byte_swap_32 (salt
.salt_buf
[2]),
7323 byte_swap_32 (salt
.salt_buf
[3]),
7324 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7325 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7326 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7327 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7328 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7329 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7330 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7331 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7338 else if (hash_mode
== 9800)
7340 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7342 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7344 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7345 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7350 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7351 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7352 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7353 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7354 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7355 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7356 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7357 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7358 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7360 else if (hash_mode
== 9810)
7362 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7364 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7366 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7367 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7372 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7373 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7374 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7375 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7376 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7377 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7378 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7379 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7380 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7382 else if (hash_mode
== 9820)
7384 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7386 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7388 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7390 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7391 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7396 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7397 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7398 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7399 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7400 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7401 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7402 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7403 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7404 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7411 else if (hash_mode
== 10000)
7415 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7417 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7419 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7423 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7424 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7425 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7426 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7427 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7428 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7429 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7430 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7431 digest_buf
[8] = 0; // needed for base64_encode ()
7434 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7436 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7440 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7442 else if (hash_mode
== 10100)
7444 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7449 byte_swap_32 (salt
.salt_buf
[0]),
7450 byte_swap_32 (salt
.salt_buf
[1]),
7451 byte_swap_32 (salt
.salt_buf
[2]),
7452 byte_swap_32 (salt
.salt_buf
[3]));
7454 else if (hash_mode
== 10200)
7456 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7458 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7462 char challenge
[100];
7464 memset (challenge
, 0, sizeof (challenge
));
7466 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7472 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7473 (char *) cram_md5
->user
,
7481 memset (response
, 0, sizeof (response
));
7483 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7485 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7487 else if (hash_mode
== 10300)
7491 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7493 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7494 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7496 uint tmp_len
= 20 + salt
.salt_len
;
7500 char base64_encoded
[100];
7502 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7504 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7506 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7508 else if (hash_mode
== 10400)
7510 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7512 pdf_t
*pdf
= &pdfs
[salt_pos
];
7514 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",
7522 byte_swap_32 (pdf
->id_buf
[0]),
7523 byte_swap_32 (pdf
->id_buf
[1]),
7524 byte_swap_32 (pdf
->id_buf
[2]),
7525 byte_swap_32 (pdf
->id_buf
[3]),
7527 byte_swap_32 (pdf
->u_buf
[0]),
7528 byte_swap_32 (pdf
->u_buf
[1]),
7529 byte_swap_32 (pdf
->u_buf
[2]),
7530 byte_swap_32 (pdf
->u_buf
[3]),
7531 byte_swap_32 (pdf
->u_buf
[4]),
7532 byte_swap_32 (pdf
->u_buf
[5]),
7533 byte_swap_32 (pdf
->u_buf
[6]),
7534 byte_swap_32 (pdf
->u_buf
[7]),
7536 byte_swap_32 (pdf
->o_buf
[0]),
7537 byte_swap_32 (pdf
->o_buf
[1]),
7538 byte_swap_32 (pdf
->o_buf
[2]),
7539 byte_swap_32 (pdf
->o_buf
[3]),
7540 byte_swap_32 (pdf
->o_buf
[4]),
7541 byte_swap_32 (pdf
->o_buf
[5]),
7542 byte_swap_32 (pdf
->o_buf
[6]),
7543 byte_swap_32 (pdf
->o_buf
[7])
7546 else if (hash_mode
== 10410)
7548 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7550 pdf_t
*pdf
= &pdfs
[salt_pos
];
7552 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",
7560 byte_swap_32 (pdf
->id_buf
[0]),
7561 byte_swap_32 (pdf
->id_buf
[1]),
7562 byte_swap_32 (pdf
->id_buf
[2]),
7563 byte_swap_32 (pdf
->id_buf
[3]),
7565 byte_swap_32 (pdf
->u_buf
[0]),
7566 byte_swap_32 (pdf
->u_buf
[1]),
7567 byte_swap_32 (pdf
->u_buf
[2]),
7568 byte_swap_32 (pdf
->u_buf
[3]),
7569 byte_swap_32 (pdf
->u_buf
[4]),
7570 byte_swap_32 (pdf
->u_buf
[5]),
7571 byte_swap_32 (pdf
->u_buf
[6]),
7572 byte_swap_32 (pdf
->u_buf
[7]),
7574 byte_swap_32 (pdf
->o_buf
[0]),
7575 byte_swap_32 (pdf
->o_buf
[1]),
7576 byte_swap_32 (pdf
->o_buf
[2]),
7577 byte_swap_32 (pdf
->o_buf
[3]),
7578 byte_swap_32 (pdf
->o_buf
[4]),
7579 byte_swap_32 (pdf
->o_buf
[5]),
7580 byte_swap_32 (pdf
->o_buf
[6]),
7581 byte_swap_32 (pdf
->o_buf
[7])
7584 else if (hash_mode
== 10420)
7586 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7588 pdf_t
*pdf
= &pdfs
[salt_pos
];
7590 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7592 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",
7600 byte_swap_32 (pdf
->id_buf
[0]),
7601 byte_swap_32 (pdf
->id_buf
[1]),
7602 byte_swap_32 (pdf
->id_buf
[2]),
7603 byte_swap_32 (pdf
->id_buf
[3]),
7605 byte_swap_32 (pdf
->u_buf
[0]),
7606 byte_swap_32 (pdf
->u_buf
[1]),
7607 byte_swap_32 (pdf
->u_buf
[2]),
7608 byte_swap_32 (pdf
->u_buf
[3]),
7609 byte_swap_32 (pdf
->u_buf
[4]),
7610 byte_swap_32 (pdf
->u_buf
[5]),
7611 byte_swap_32 (pdf
->u_buf
[6]),
7612 byte_swap_32 (pdf
->u_buf
[7]),
7614 byte_swap_32 (pdf
->o_buf
[0]),
7615 byte_swap_32 (pdf
->o_buf
[1]),
7616 byte_swap_32 (pdf
->o_buf
[2]),
7617 byte_swap_32 (pdf
->o_buf
[3]),
7618 byte_swap_32 (pdf
->o_buf
[4]),
7619 byte_swap_32 (pdf
->o_buf
[5]),
7620 byte_swap_32 (pdf
->o_buf
[6]),
7621 byte_swap_32 (pdf
->o_buf
[7]),
7629 else if (hash_mode
== 10500)
7631 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7633 pdf_t
*pdf
= &pdfs
[salt_pos
];
7635 if (pdf
->id_len
== 32)
7637 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",
7645 byte_swap_32 (pdf
->id_buf
[0]),
7646 byte_swap_32 (pdf
->id_buf
[1]),
7647 byte_swap_32 (pdf
->id_buf
[2]),
7648 byte_swap_32 (pdf
->id_buf
[3]),
7649 byte_swap_32 (pdf
->id_buf
[4]),
7650 byte_swap_32 (pdf
->id_buf
[5]),
7651 byte_swap_32 (pdf
->id_buf
[6]),
7652 byte_swap_32 (pdf
->id_buf
[7]),
7654 byte_swap_32 (pdf
->u_buf
[0]),
7655 byte_swap_32 (pdf
->u_buf
[1]),
7656 byte_swap_32 (pdf
->u_buf
[2]),
7657 byte_swap_32 (pdf
->u_buf
[3]),
7658 byte_swap_32 (pdf
->u_buf
[4]),
7659 byte_swap_32 (pdf
->u_buf
[5]),
7660 byte_swap_32 (pdf
->u_buf
[6]),
7661 byte_swap_32 (pdf
->u_buf
[7]),
7663 byte_swap_32 (pdf
->o_buf
[0]),
7664 byte_swap_32 (pdf
->o_buf
[1]),
7665 byte_swap_32 (pdf
->o_buf
[2]),
7666 byte_swap_32 (pdf
->o_buf
[3]),
7667 byte_swap_32 (pdf
->o_buf
[4]),
7668 byte_swap_32 (pdf
->o_buf
[5]),
7669 byte_swap_32 (pdf
->o_buf
[6]),
7670 byte_swap_32 (pdf
->o_buf
[7])
7675 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",
7683 byte_swap_32 (pdf
->id_buf
[0]),
7684 byte_swap_32 (pdf
->id_buf
[1]),
7685 byte_swap_32 (pdf
->id_buf
[2]),
7686 byte_swap_32 (pdf
->id_buf
[3]),
7688 byte_swap_32 (pdf
->u_buf
[0]),
7689 byte_swap_32 (pdf
->u_buf
[1]),
7690 byte_swap_32 (pdf
->u_buf
[2]),
7691 byte_swap_32 (pdf
->u_buf
[3]),
7692 byte_swap_32 (pdf
->u_buf
[4]),
7693 byte_swap_32 (pdf
->u_buf
[5]),
7694 byte_swap_32 (pdf
->u_buf
[6]),
7695 byte_swap_32 (pdf
->u_buf
[7]),
7697 byte_swap_32 (pdf
->o_buf
[0]),
7698 byte_swap_32 (pdf
->o_buf
[1]),
7699 byte_swap_32 (pdf
->o_buf
[2]),
7700 byte_swap_32 (pdf
->o_buf
[3]),
7701 byte_swap_32 (pdf
->o_buf
[4]),
7702 byte_swap_32 (pdf
->o_buf
[5]),
7703 byte_swap_32 (pdf
->o_buf
[6]),
7704 byte_swap_32 (pdf
->o_buf
[7])
7708 else if (hash_mode
== 10600)
7710 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7712 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7713 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7715 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7717 else if (hash_mode
== 10700)
7719 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7721 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7722 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7724 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7726 else if (hash_mode
== 10900)
7728 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7730 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7731 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7733 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7735 else if (hash_mode
== 11100)
7737 uint32_t salt_challenge
= salt
.salt_buf
[0];
7739 salt_challenge
= byte_swap_32 (salt_challenge
);
7741 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7743 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7744 SIGNATURE_POSTGRESQL_AUTH
,
7752 else if (hash_mode
== 11200)
7754 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7755 SIGNATURE_MYSQL_AUTH
,
7756 (unsigned char *) salt
.salt_buf
,
7763 else if (hash_mode
== 11300)
7765 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7767 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7769 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7770 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7771 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7773 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7774 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7775 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7777 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7779 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7781 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7784 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7786 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7788 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7791 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7793 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7795 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7798 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7799 SIGNATURE_BITCOIN_WALLET
,
7803 (unsigned char *) salt
.salt_buf
,
7811 free (cry_master_buf
);
7813 free (public_key_buf
);
7815 else if (hash_mode
== 11400)
7817 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7819 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7820 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7822 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7824 else if (hash_mode
== 11600)
7826 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7828 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7830 const uint data_len
= seven_zip
->data_len
;
7832 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7834 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7836 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7838 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7841 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7842 SIGNATURE_SEVEN_ZIP
,
7846 (char *) seven_zip
->salt_buf
,
7848 seven_zip
->iv_buf
[0],
7849 seven_zip
->iv_buf
[1],
7850 seven_zip
->iv_buf
[2],
7851 seven_zip
->iv_buf
[3],
7853 seven_zip
->data_len
,
7854 seven_zip
->unpack_size
,
7859 else if (hash_mode
== 11700)
7861 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7871 else if (hash_mode
== 11800)
7873 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7891 else if (hash_mode
== 11900)
7893 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7895 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7896 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7898 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7900 else if (hash_mode
== 12000)
7902 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7904 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7905 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7907 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7909 else if (hash_mode
== 12100)
7911 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7913 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7914 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7916 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7918 else if (hash_mode
== 12200)
7920 uint
*ptr_digest
= digest_buf
;
7921 uint
*ptr_salt
= salt
.salt_buf
;
7923 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7930 else if (hash_mode
== 12300)
7932 uint
*ptr_digest
= digest_buf
;
7933 uint
*ptr_salt
= salt
.salt_buf
;
7935 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",
7936 ptr_digest
[ 0], ptr_digest
[ 1],
7937 ptr_digest
[ 2], ptr_digest
[ 3],
7938 ptr_digest
[ 4], ptr_digest
[ 5],
7939 ptr_digest
[ 6], ptr_digest
[ 7],
7940 ptr_digest
[ 8], ptr_digest
[ 9],
7941 ptr_digest
[10], ptr_digest
[11],
7942 ptr_digest
[12], ptr_digest
[13],
7943 ptr_digest
[14], ptr_digest
[15],
7949 else if (hash_mode
== 12400)
7951 // encode iteration count
7955 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7956 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7957 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7958 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7963 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7964 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7965 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7966 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7971 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7973 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7974 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7976 memcpy (tmp_buf
, digest_buf
, 8);
7978 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7982 // fill the resulting buffer
7984 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7986 else if (hash_mode
== 12500)
7988 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7990 byte_swap_32 (salt
.salt_buf
[0]),
7991 byte_swap_32 (salt
.salt_buf
[1]),
7997 else if (hash_mode
== 12600)
7999 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8000 digest_buf
[0] + salt
.salt_buf_pc
[0],
8001 digest_buf
[1] + salt
.salt_buf_pc
[1],
8002 digest_buf
[2] + salt
.salt_buf_pc
[2],
8003 digest_buf
[3] + salt
.salt_buf_pc
[3],
8004 digest_buf
[4] + salt
.salt_buf_pc
[4],
8005 digest_buf
[5] + salt
.salt_buf_pc
[5],
8006 digest_buf
[6] + salt
.salt_buf_pc
[6],
8007 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8009 else if (hash_mode
== 12700)
8011 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8013 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8014 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8016 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8018 else if (hash_mode
== 12800)
8020 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
8022 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",
8035 byte_swap_32 (digest_buf
[0]),
8036 byte_swap_32 (digest_buf
[1]),
8037 byte_swap_32 (digest_buf
[2]),
8038 byte_swap_32 (digest_buf
[3]),
8039 byte_swap_32 (digest_buf
[4]),
8040 byte_swap_32 (digest_buf
[5]),
8041 byte_swap_32 (digest_buf
[6]),
8042 byte_swap_32 (digest_buf
[7])
8047 if (hash_type
== HASH_TYPE_MD4
)
8049 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8055 else if (hash_type
== HASH_TYPE_MD5
)
8057 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8063 else if (hash_type
== HASH_TYPE_SHA1
)
8065 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8072 else if (hash_type
== HASH_TYPE_SHA256
)
8074 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8084 else if (hash_type
== HASH_TYPE_SHA384
)
8086 uint
*ptr
= digest_buf
;
8088 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8096 else if (hash_type
== HASH_TYPE_SHA512
)
8098 uint
*ptr
= digest_buf
;
8100 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8110 else if (hash_type
== HASH_TYPE_LM
)
8112 snprintf (out_buf
, len
-1, "%08x%08x",
8116 else if (hash_type
== HASH_TYPE_ORACLEH
)
8118 snprintf (out_buf
, len
-1, "%08X%08X",
8122 else if (hash_type
== HASH_TYPE_BCRYPT
)
8124 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8125 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8127 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8129 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8131 else if (hash_type
== HASH_TYPE_KECCAK
)
8133 uint
*ptr
= digest_buf
;
8135 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",
8163 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8165 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8167 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8174 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8176 digest_buf
[ 0] = digest_buf
[ 0];
8177 digest_buf
[ 1] = digest_buf
[ 1];
8178 digest_buf
[ 2] = digest_buf
[ 2];
8179 digest_buf
[ 3] = digest_buf
[ 3];
8180 digest_buf
[ 4] = digest_buf
[ 4];
8181 digest_buf
[ 5] = digest_buf
[ 5];
8182 digest_buf
[ 6] = digest_buf
[ 6];
8183 digest_buf
[ 7] = digest_buf
[ 7];
8184 digest_buf
[ 8] = digest_buf
[ 8];
8185 digest_buf
[ 9] = digest_buf
[ 9];
8186 digest_buf
[10] = digest_buf
[10];
8187 digest_buf
[11] = digest_buf
[11];
8188 digest_buf
[12] = digest_buf
[12];
8189 digest_buf
[13] = digest_buf
[13];
8190 digest_buf
[14] = digest_buf
[14];
8191 digest_buf
[15] = digest_buf
[15];
8193 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8211 else if (hash_type
== HASH_TYPE_GOST
)
8213 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8223 else if (hash_type
== HASH_TYPE_MYSQL
)
8225 snprintf (out_buf
, len
-1, "%08x%08x",
8229 else if (hash_type
== HASH_TYPE_LOTUS5
)
8231 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8237 else if (hash_type
== HASH_TYPE_LOTUS6
)
8239 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8240 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8241 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8242 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8246 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8247 memcpy (buf
+ 5, digest_buf
, 9);
8251 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8253 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8256 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8258 else if (hash_type
== HASH_TYPE_LOTUS8
)
8262 memset (buf
, 0, sizeof (buf
));
8266 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8272 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8276 buf
[26] = salt
.salt_buf_pc
[0];
8277 buf
[27] = salt
.salt_buf_pc
[1];
8281 memcpy (buf
+ 28, digest_buf
, 8);
8283 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8287 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8289 else if (hash_type
== HASH_TYPE_CRC32
)
8291 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8295 if (salt_type
== SALT_TYPE_INTERN
)
8297 size_t pos
= strlen (out_buf
);
8299 out_buf
[pos
] = data
.separator
;
8301 char *ptr
= (char *) salt
.salt_buf
;
8303 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8305 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8309 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8311 memset (hccap
, 0, sizeof (hccap_t
));
8313 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8315 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8317 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8318 wpa_t
*wpa
= &wpas
[salt_pos
];
8320 hccap
->keyver
= wpa
->keyver
;
8322 hccap
->eapol_size
= wpa
->eapol_size
;
8324 if (wpa
->keyver
!= 1)
8328 for (uint i
= 0; i
< 64; i
++)
8330 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8333 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8337 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8342 for (int i
= 5; i
< 25; i
++)
8344 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8347 char *pke_ptr
= (char *) pke_tmp
;
8349 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8350 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8351 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8352 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8354 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8356 uint dgst_size
= data
.dgst_size
;
8358 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8360 if (wpa
->keyver
!= 1)
8364 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8365 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8366 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8367 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8369 memcpy (hccap
->keymic
, digest_tmp
, 16);
8373 memcpy (hccap
->keymic
, digest_ptr
, 16);
8377 void SuspendThreads ()
8379 if (data
.devices_status
== STATUS_RUNNING
)
8381 hc_timer_set (&data
.timer_paused
);
8383 data
.devices_status
= STATUS_PAUSED
;
8385 log_info ("Paused");
8389 void ResumeThreads ()
8391 if (data
.devices_status
== STATUS_PAUSED
)
8395 hc_timer_get (data
.timer_paused
, ms_paused
);
8397 data
.ms_paused
+= ms_paused
;
8399 data
.devices_status
= STATUS_RUNNING
;
8401 log_info ("Resumed");
8407 if (data
.devices_status
!= STATUS_RUNNING
) return;
8409 data
.devices_status
= STATUS_BYPASS
;
8411 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8414 void stop_at_checkpoint ()
8416 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8418 if (data
.devices_status
!= STATUS_RUNNING
) return;
8421 // this feature only makes sense if --restore-disable was not specified
8423 if (data
.restore_disable
== 1)
8425 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8430 // check if monitoring of Restore Point updates should be enabled or disabled
8432 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8434 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8436 // save the current restore point value
8438 data
.checkpoint_cur_words
= get_lowest_words_done ();
8440 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8444 data
.devices_status
= STATUS_RUNNING
;
8446 // reset the global value for checkpoint checks
8448 data
.checkpoint_cur_words
= 0;
8450 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8456 if (data
.devices_status
== STATUS_INIT
) return;
8457 if (data
.devices_status
== STATUS_STARTING
) return;
8459 data
.devices_status
= STATUS_ABORTED
;
8464 if (data
.devices_status
== STATUS_INIT
) return;
8465 if (data
.devices_status
== STATUS_STARTING
) return;
8467 data
.devices_status
= STATUS_QUIT
;
8470 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8474 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8478 memset (&st
, 0, sizeof (st
));
8480 stat (kernel_file
, &st
);
8482 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8484 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8486 if (num_read
!= (size_t) st
.st_size
)
8488 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8495 buf
[st
.st_size
] = 0;
8497 for (int i
= 0; i
< num_devices
; i
++)
8499 kernel_lengths
[i
] = (size_t) st
.st_size
;
8501 kernel_sources
[i
] = buf
;
8506 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8514 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8516 FILE *fp
= fopen (dst
, "wb");
8518 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8528 restore_data_t
*init_restore (int argc
, char **argv
)
8530 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8532 if (data
.restore_disable
== 0)
8534 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8538 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8542 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8551 char pidbin
[BUFSIZ
];
8556 memset (pidbin
, 0, sizeof (pidbin
));
8558 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8560 FILE *fd
= fopen (pidbin
, "rb");
8564 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8566 pidbin
[pidbin_len
] = 0;
8570 char *argv0_r
= strrchr (argv
[0], '/');
8572 char *pidbin_r
= strrchr (pidbin
, '/');
8574 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8576 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8578 if (strcmp (argv0_r
, pidbin_r
) == 0)
8580 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8587 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8589 char pidbin2
[BUFSIZ
];
8593 memset (pidbin2
, 0, sizeof (pidbin2
));
8595 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8596 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8598 pidbin
[pidbin_len
] = 0;
8599 pidbin2
[pidbin2_len
] = 0;
8603 if (strcmp (pidbin
, pidbin2
) == 0)
8605 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8613 if (rd
->version_bin
< RESTORE_MIN
)
8615 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8622 memset (rd
, 0, sizeof (restore_data_t
));
8624 rd
->version_bin
= VERSION_BIN
;
8627 rd
->pid
= getpid ();
8629 rd
->pid
= GetCurrentProcessId ();
8632 if (getcwd (rd
->cwd
, 255) == NULL
)
8645 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8647 FILE *fp
= fopen (eff_restore_file
, "rb");
8651 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8656 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8658 log_error ("ERROR: cannot read %s", eff_restore_file
);
8663 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8665 for (uint i
= 0; i
< rd
->argc
; i
++)
8669 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8671 log_error ("ERROR: cannot read %s", eff_restore_file
);
8676 size_t len
= strlen (buf
);
8678 if (len
) buf
[len
- 1] = 0;
8680 rd
->argv
[i
] = mystrdup (buf
);
8687 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8691 log_error ("Restore file is corrupted");
8694 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8696 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8698 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8703 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8707 if (chdir (rd
->cwd
))
8709 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8715 uint64_t get_lowest_words_done ()
8717 uint64_t words_cur
= -1;
8719 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8721 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8723 const uint64_t words_done
= device_param
->words_done
;
8725 if (words_done
< words_cur
) words_cur
= words_done
;
8728 // It's possible that a GPU's workload isn't finished right after a restore-case.
8729 // In that case, this function would return 0 and overwrite the real restore point
8730 // There's also data.words_cur which is set to rd->words_cur but it changes while
8731 // the attack is running therefore we should stick to rd->words_cur.
8732 // Note that -s influences rd->words_cur we should keep a close look on that.
8734 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8739 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8741 uint64_t words_cur
= get_lowest_words_done ();
8743 rd
->words_cur
= words_cur
;
8745 FILE *fp
= fopen (new_restore_file
, "wb");
8749 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8754 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8756 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8761 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8763 for (uint i
= 0; i
< rd
->argc
; i
++)
8765 fprintf (fp
, "%s", rd
->argv
[i
]);
8771 fsync (fileno (fp
));
8776 void cycle_restore ()
8778 const char *eff_restore_file
= data
.eff_restore_file
;
8779 const char *new_restore_file
= data
.new_restore_file
;
8781 restore_data_t
*rd
= data
.rd
;
8783 write_restore (new_restore_file
, rd
);
8787 memset (&st
, 0, sizeof(st
));
8789 if (stat (eff_restore_file
, &st
) == 0)
8791 if (unlink (eff_restore_file
))
8793 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8797 if (rename (new_restore_file
, eff_restore_file
))
8799 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8803 void check_checkpoint ()
8805 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8807 uint64_t words_cur
= get_lowest_words_done ();
8809 if (words_cur
!= data
.checkpoint_cur_words
)
8819 uint
set_gpu_accel (uint hash_mode
)
8823 case 0: return GET_ACCEL (0);
8824 case 10: return GET_ACCEL (10);
8825 case 11: return GET_ACCEL (11);
8826 case 12: return GET_ACCEL (12);
8827 case 20: return GET_ACCEL (20);
8828 case 21: return GET_ACCEL (21);
8829 case 22: return GET_ACCEL (22);
8830 case 23: return GET_ACCEL (23);
8831 case 30: return GET_ACCEL (30);
8832 case 40: return GET_ACCEL (40);
8833 case 50: return GET_ACCEL (50);
8834 case 60: return GET_ACCEL (60);
8835 case 100: return GET_ACCEL (100);
8836 case 101: return GET_ACCEL (101);
8837 case 110: return GET_ACCEL (110);
8838 case 111: return GET_ACCEL (111);
8839 case 112: return GET_ACCEL (112);
8840 case 120: return GET_ACCEL (120);
8841 case 121: return GET_ACCEL (121);
8842 case 122: return GET_ACCEL (122);
8843 case 124: return GET_ACCEL (124);
8844 case 130: return GET_ACCEL (130);
8845 case 131: return GET_ACCEL (131);
8846 case 132: return GET_ACCEL (132);
8847 case 133: return GET_ACCEL (133);
8848 case 140: return GET_ACCEL (140);
8849 case 141: return GET_ACCEL (141);
8850 case 150: return GET_ACCEL (150);
8851 case 160: return GET_ACCEL (160);
8852 case 190: return GET_ACCEL (190);
8853 case 200: return GET_ACCEL (200);
8854 case 300: return GET_ACCEL (300);
8855 case 400: return GET_ACCEL (400);
8856 case 500: return GET_ACCEL (500);
8857 case 501: return GET_ACCEL (501);
8858 case 900: return GET_ACCEL (900);
8859 case 910: return GET_ACCEL (910);
8860 case 1000: return GET_ACCEL (1000);
8861 case 1100: return GET_ACCEL (1100);
8862 case 1400: return GET_ACCEL (1400);
8863 case 1410: return GET_ACCEL (1410);
8864 case 1420: return GET_ACCEL (1420);
8865 case 1421: return GET_ACCEL (1421);
8866 case 1430: return GET_ACCEL (1430);
8867 case 1440: return GET_ACCEL (1440);
8868 case 1441: return GET_ACCEL (1441);
8869 case 1450: return GET_ACCEL (1450);
8870 case 1460: return GET_ACCEL (1460);
8871 case 1500: return GET_ACCEL (1500);
8872 case 1600: return GET_ACCEL (1600);
8873 case 1700: return GET_ACCEL (1700);
8874 case 1710: return GET_ACCEL (1710);
8875 case 1711: return GET_ACCEL (1711);
8876 case 1720: return GET_ACCEL (1720);
8877 case 1722: return GET_ACCEL (1722);
8878 case 1730: return GET_ACCEL (1730);
8879 case 1731: return GET_ACCEL (1731);
8880 case 1740: return GET_ACCEL (1740);
8881 case 1750: return GET_ACCEL (1750);
8882 case 1760: return GET_ACCEL (1760);
8883 case 1800: return GET_ACCEL (1800);
8884 case 2100: return GET_ACCEL (2100);
8885 case 2400: return GET_ACCEL (2400);
8886 case 2410: return GET_ACCEL (2410);
8887 case 2500: return GET_ACCEL (2500);
8888 case 2600: return GET_ACCEL (2600);
8889 case 2611: return GET_ACCEL (2611);
8890 case 2612: return GET_ACCEL (2612);
8891 case 2711: return GET_ACCEL (2711);
8892 case 2811: return GET_ACCEL (2811);
8893 case 3000: return GET_ACCEL (3000);
8894 case 3100: return GET_ACCEL (3100);
8895 case 3200: return GET_ACCEL (3200);
8896 case 3710: return GET_ACCEL (3710);
8897 case 3711: return GET_ACCEL (3711);
8898 case 3800: return GET_ACCEL (3800);
8899 case 4300: return GET_ACCEL (4300);
8900 case 4400: return GET_ACCEL (4400);
8901 case 4500: return GET_ACCEL (4500);
8902 case 4700: return GET_ACCEL (4700);
8903 case 4800: return GET_ACCEL (4800);
8904 case 4900: return GET_ACCEL (4900);
8905 case 5000: return GET_ACCEL (5000);
8906 case 5100: return GET_ACCEL (5100);
8907 case 5200: return GET_ACCEL (5200);
8908 case 5300: return GET_ACCEL (5300);
8909 case 5400: return GET_ACCEL (5400);
8910 case 5500: return GET_ACCEL (5500);
8911 case 5600: return GET_ACCEL (5600);
8912 case 5700: return GET_ACCEL (5700);
8913 case 5800: return GET_ACCEL (5800);
8914 case 6000: return GET_ACCEL (6000);
8915 case 6100: return GET_ACCEL (6100);
8916 case 6211: return GET_ACCEL (6211);
8917 case 6212: return GET_ACCEL (6212);
8918 case 6213: return GET_ACCEL (6213);
8919 case 6221: return GET_ACCEL (6221);
8920 case 6222: return GET_ACCEL (6222);
8921 case 6223: return GET_ACCEL (6223);
8922 case 6231: return GET_ACCEL (6231);
8923 case 6232: return GET_ACCEL (6232);
8924 case 6233: return GET_ACCEL (6233);
8925 case 6241: return GET_ACCEL (6241);
8926 case 6242: return GET_ACCEL (6242);
8927 case 6243: return GET_ACCEL (6243);
8928 case 6300: return GET_ACCEL (6300);
8929 case 6400: return GET_ACCEL (6400);
8930 case 6500: return GET_ACCEL (6500);
8931 case 6600: return GET_ACCEL (6600);
8932 case 6700: return GET_ACCEL (6700);
8933 case 6800: return GET_ACCEL (6800);
8934 case 6900: return GET_ACCEL (6900);
8935 case 7100: return GET_ACCEL (7100);
8936 case 7200: return GET_ACCEL (7200);
8937 case 7300: return GET_ACCEL (7300);
8938 case 7400: return GET_ACCEL (7400);
8939 case 7500: return GET_ACCEL (7500);
8940 case 7600: return GET_ACCEL (7600);
8941 case 7700: return GET_ACCEL (7700);
8942 case 7800: return GET_ACCEL (7800);
8943 case 7900: return GET_ACCEL (7900);
8944 case 8000: return GET_ACCEL (8000);
8945 case 8100: return GET_ACCEL (8100);
8946 case 8200: return GET_ACCEL (8200);
8947 case 8300: return GET_ACCEL (8300);
8948 case 8400: return GET_ACCEL (8400);
8949 case 8500: return GET_ACCEL (8500);
8950 case 8600: return GET_ACCEL (8600);
8951 case 8700: return GET_ACCEL (8700);
8952 case 8800: return GET_ACCEL (8800);
8953 case 8900: return GET_ACCEL (8900);
8954 case 9000: return GET_ACCEL (9000);
8955 case 9100: return GET_ACCEL (9100);
8956 case 9200: return GET_ACCEL (9200);
8957 case 9300: return GET_ACCEL (9300);
8958 case 9400: return GET_ACCEL (9400);
8959 case 9500: return GET_ACCEL (9500);
8960 case 9600: return GET_ACCEL (9600);
8961 case 9700: return GET_ACCEL (9700);
8962 case 9710: return GET_ACCEL (9710);
8963 case 9720: return GET_ACCEL (9720);
8964 case 9800: return GET_ACCEL (9800);
8965 case 9810: return GET_ACCEL (9810);
8966 case 9820: return GET_ACCEL (9820);
8967 case 9900: return GET_ACCEL (9900);
8968 case 10000: return GET_ACCEL (10000);
8969 case 10100: return GET_ACCEL (10100);
8970 case 10200: return GET_ACCEL (10200);
8971 case 10300: return GET_ACCEL (10300);
8972 case 10400: return GET_ACCEL (10400);
8973 case 10410: return GET_ACCEL (10410);
8974 case 10420: return GET_ACCEL (10420);
8975 case 10500: return GET_ACCEL (10500);
8976 case 10600: return GET_ACCEL (10600);
8977 case 10700: return GET_ACCEL (10700);
8978 case 10800: return GET_ACCEL (10800);
8979 case 10900: return GET_ACCEL (10900);
8980 case 11000: return GET_ACCEL (11000);
8981 case 11100: return GET_ACCEL (11100);
8982 case 11200: return GET_ACCEL (11200);
8983 case 11300: return GET_ACCEL (11300);
8984 case 11400: return GET_ACCEL (11400);
8985 case 11500: return GET_ACCEL (11500);
8986 case 11600: return GET_ACCEL (11600);
8987 case 11700: return GET_ACCEL (11700);
8988 case 11800: return GET_ACCEL (11800);
8989 case 11900: return GET_ACCEL (11900);
8990 case 12000: return GET_ACCEL (12000);
8991 case 12100: return GET_ACCEL (12100);
8992 case 12200: return GET_ACCEL (12200);
8993 case 12300: return GET_ACCEL (12300);
8994 case 12400: return GET_ACCEL (12400);
8995 case 12500: return GET_ACCEL (12500);
8996 case 12600: return GET_ACCEL (12600);
8997 case 12700: return GET_ACCEL (12700);
8998 case 12800: return GET_ACCEL (12800);
9004 uint
set_gpu_loops (uint hash_mode
)
9008 case 0: return GET_LOOPS (0);
9009 case 10: return GET_LOOPS (10);
9010 case 11: return GET_LOOPS (11);
9011 case 12: return GET_LOOPS (12);
9012 case 20: return GET_LOOPS (20);
9013 case 21: return GET_LOOPS (21);
9014 case 22: return GET_LOOPS (22);
9015 case 23: return GET_LOOPS (23);
9016 case 30: return GET_LOOPS (30);
9017 case 40: return GET_LOOPS (40);
9018 case 50: return GET_LOOPS (50);
9019 case 60: return GET_LOOPS (60);
9020 case 100: return GET_LOOPS (100);
9021 case 101: return GET_LOOPS (101);
9022 case 110: return GET_LOOPS (110);
9023 case 111: return GET_LOOPS (111);
9024 case 112: return GET_LOOPS (112);
9025 case 120: return GET_LOOPS (120);
9026 case 121: return GET_LOOPS (121);
9027 case 122: return GET_LOOPS (122);
9028 case 124: return GET_LOOPS (124);
9029 case 130: return GET_LOOPS (130);
9030 case 131: return GET_LOOPS (131);
9031 case 132: return GET_LOOPS (132);
9032 case 133: return GET_LOOPS (133);
9033 case 140: return GET_LOOPS (140);
9034 case 141: return GET_LOOPS (141);
9035 case 150: return GET_LOOPS (150);
9036 case 160: return GET_LOOPS (160);
9037 case 190: return GET_LOOPS (190);
9038 case 200: return GET_LOOPS (200);
9039 case 300: return GET_LOOPS (300);
9040 case 400: return GET_LOOPS (400);
9041 case 500: return GET_LOOPS (500);
9042 case 501: return GET_LOOPS (501);
9043 case 900: return GET_LOOPS (900);
9044 case 910: return GET_LOOPS (910);
9045 case 1000: return GET_LOOPS (1000);
9046 case 1100: return GET_LOOPS (1100);
9047 case 1400: return GET_LOOPS (1400);
9048 case 1410: return GET_LOOPS (1410);
9049 case 1420: return GET_LOOPS (1420);
9050 case 1421: return GET_LOOPS (1421);
9051 case 1430: return GET_LOOPS (1430);
9052 case 1440: return GET_LOOPS (1440);
9053 case 1441: return GET_LOOPS (1441);
9054 case 1450: return GET_LOOPS (1450);
9055 case 1460: return GET_LOOPS (1460);
9056 case 1500: return GET_LOOPS (1500);
9057 case 1600: return GET_LOOPS (1600);
9058 case 1700: return GET_LOOPS (1700);
9059 case 1710: return GET_LOOPS (1710);
9060 case 1711: return GET_LOOPS (1711);
9061 case 1720: return GET_LOOPS (1720);
9062 case 1722: return GET_LOOPS (1722);
9063 case 1730: return GET_LOOPS (1730);
9064 case 1731: return GET_LOOPS (1731);
9065 case 1740: return GET_LOOPS (1740);
9066 case 1750: return GET_LOOPS (1750);
9067 case 1760: return GET_LOOPS (1760);
9068 case 1800: return GET_LOOPS (1800);
9069 case 2100: return GET_LOOPS (2100);
9070 case 2400: return GET_LOOPS (2400);
9071 case 2410: return GET_LOOPS (2410);
9072 case 2500: return GET_LOOPS (2500);
9073 case 2600: return GET_LOOPS (2600);
9074 case 2611: return GET_LOOPS (2611);
9075 case 2612: return GET_LOOPS (2612);
9076 case 2711: return GET_LOOPS (2711);
9077 case 2811: return GET_LOOPS (2811);
9078 case 3000: return GET_LOOPS (3000);
9079 case 3100: return GET_LOOPS (3100);
9080 case 3200: return GET_LOOPS (3200);
9081 case 3710: return GET_LOOPS (3710);
9082 case 3711: return GET_LOOPS (3711);
9083 case 3800: return GET_LOOPS (3800);
9084 case 4300: return GET_LOOPS (4300);
9085 case 4400: return GET_LOOPS (4400);
9086 case 4500: return GET_LOOPS (4500);
9087 case 4700: return GET_LOOPS (4700);
9088 case 4800: return GET_LOOPS (4800);
9089 case 4900: return GET_LOOPS (4900);
9090 case 5000: return GET_LOOPS (5000);
9091 case 5100: return GET_LOOPS (5100);
9092 case 5200: return GET_LOOPS (5200);
9093 case 5300: return GET_LOOPS (5300);
9094 case 5400: return GET_LOOPS (5400);
9095 case 5500: return GET_LOOPS (5500);
9096 case 5600: return GET_LOOPS (5600);
9097 case 5700: return GET_LOOPS (5700);
9098 case 5800: return GET_LOOPS (5800);
9099 case 6000: return GET_LOOPS (6000);
9100 case 6100: return GET_LOOPS (6100);
9101 case 6211: return GET_LOOPS (6211);
9102 case 6212: return GET_LOOPS (6212);
9103 case 6213: return GET_LOOPS (6213);
9104 case 6221: return GET_LOOPS (6221);
9105 case 6222: return GET_LOOPS (6222);
9106 case 6223: return GET_LOOPS (6223);
9107 case 6231: return GET_LOOPS (6231);
9108 case 6232: return GET_LOOPS (6232);
9109 case 6233: return GET_LOOPS (6233);
9110 case 6241: return GET_LOOPS (6241);
9111 case 6242: return GET_LOOPS (6242);
9112 case 6243: return GET_LOOPS (6243);
9113 case 6300: return GET_LOOPS (6300);
9114 case 6400: return GET_LOOPS (6400);
9115 case 6500: return GET_LOOPS (6500);
9116 case 6600: return GET_LOOPS (6600);
9117 case 6700: return GET_LOOPS (6700);
9118 case 6800: return GET_LOOPS (6800);
9119 case 6900: return GET_LOOPS (6900);
9120 case 7100: return GET_LOOPS (7100);
9121 case 7200: return GET_LOOPS (7200);
9122 case 7300: return GET_LOOPS (7300);
9123 case 7400: return GET_LOOPS (7400);
9124 case 7500: return GET_LOOPS (7500);
9125 case 7600: return GET_LOOPS (7600);
9126 case 7700: return GET_LOOPS (7700);
9127 case 7800: return GET_LOOPS (7800);
9128 case 7900: return GET_LOOPS (7900);
9129 case 8000: return GET_LOOPS (8000);
9130 case 8100: return GET_LOOPS (8100);
9131 case 8200: return GET_LOOPS (8200);
9132 case 8300: return GET_LOOPS (8300);
9133 case 8400: return GET_LOOPS (8400);
9134 case 8500: return GET_LOOPS (8500);
9135 case 8600: return GET_LOOPS (8600);
9136 case 8700: return GET_LOOPS (8700);
9137 case 8800: return GET_LOOPS (8800);
9138 case 8900: return GET_LOOPS (8900);
9139 case 9000: return GET_LOOPS (9000);
9140 case 9100: return GET_LOOPS (9100);
9141 case 9200: return GET_LOOPS (9200);
9142 case 9300: return GET_LOOPS (9300);
9143 case 9400: return GET_LOOPS (9400);
9144 case 9500: return GET_LOOPS (9500);
9145 case 9600: return GET_LOOPS (9600);
9146 case 9700: return GET_LOOPS (9700);
9147 case 9710: return GET_LOOPS (9710);
9148 case 9720: return GET_LOOPS (9720);
9149 case 9800: return GET_LOOPS (9800);
9150 case 9810: return GET_LOOPS (9810);
9151 case 9820: return GET_LOOPS (9820);
9152 case 9900: return GET_LOOPS (9900);
9153 case 10000: return GET_LOOPS (10000);
9154 case 10100: return GET_LOOPS (10100);
9155 case 10200: return GET_LOOPS (10200);
9156 case 10300: return GET_LOOPS (10300);
9157 case 10400: return GET_LOOPS (10400);
9158 case 10410: return GET_LOOPS (10410);
9159 case 10420: return GET_LOOPS (10420);
9160 case 10500: return GET_LOOPS (10500);
9161 case 10600: return GET_LOOPS (10600);
9162 case 10700: return GET_LOOPS (10700);
9163 case 10800: return GET_LOOPS (10800);
9164 case 10900: return GET_LOOPS (10900);
9165 case 11000: return GET_LOOPS (11000);
9166 case 11100: return GET_LOOPS (11100);
9167 case 11200: return GET_LOOPS (11200);
9168 case 11300: return GET_LOOPS (11300);
9169 case 11400: return GET_LOOPS (11400);
9170 case 11500: return GET_LOOPS (11500);
9171 case 11600: return GET_LOOPS (11600);
9172 case 11700: return GET_LOOPS (11700);
9173 case 11800: return GET_LOOPS (11800);
9174 case 11900: return GET_LOOPS (11900);
9175 case 12000: return GET_LOOPS (12000);
9176 case 12100: return GET_LOOPS (12100);
9177 case 12200: return GET_LOOPS (12200);
9178 case 12300: return GET_LOOPS (12300);
9179 case 12400: return GET_LOOPS (12400);
9180 case 12500: return GET_LOOPS (12500);
9181 case 12600: return GET_LOOPS (12600);
9182 case 12700: return GET_LOOPS (12700);
9183 case 12800: return GET_LOOPS (12800);
9193 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9197 if (salt_len
> sizeof(tmp
))
9202 memset (tmp
, 0, sizeof (tmp
));
9203 memcpy (tmp
, in
, salt_len
);
9205 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9207 if ((salt_len
% 2) == 0)
9209 uint new_salt_len
= salt_len
/ 2;
9211 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9213 char p0
= tmp
[j
+ 0];
9214 char p1
= tmp
[j
+ 1];
9216 tmp
[i
] = hex_convert (p1
) << 0;
9217 tmp
[i
] |= hex_convert (p0
) << 4;
9220 salt_len
= new_salt_len
;
9227 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9229 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9232 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9234 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9238 uint
*tmp_uint
= (uint
*) tmp
;
9240 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9241 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9242 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9243 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9244 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9245 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9246 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9247 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9248 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9249 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9251 salt_len
= salt_len
* 2;
9259 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9261 lowercase (tmp
, salt_len
);
9264 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9266 uppercase (tmp
, salt_len
);
9269 uint len
= salt_len
;
9271 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9276 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9281 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9283 uint
*tmp_uint
= (uint
*) tmp
;
9289 for (uint i
= 0; i
< max
; i
++)
9291 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9294 // Important: we may need to increase the length of memcpy since
9295 // we don't want to "loose" some swapped bytes (could happen if
9296 // they do not perfectly fit in the 4-byte blocks)
9297 // Memcpy does always copy the bytes in the BE order, but since
9298 // we swapped them, some important bytes could be in positions
9299 // we normally skip with the original len
9301 if (len
% 4) len
+= 4 - (len
% 4);
9304 memcpy (out
, tmp
, len
);
9309 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9311 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9313 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9315 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9317 salt_t
*salt
= hash_buf
->salt
;
9319 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9321 char *iter_pos
= input_buf
+ 4;
9323 salt
->salt_iter
= 1 << atoi (iter_pos
);
9325 char *salt_pos
= strchr (iter_pos
, '$');
9327 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9333 salt
->salt_len
= salt_len
;
9337 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9339 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9343 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9345 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9346 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9347 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9348 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9350 char *hash_pos
= salt_pos
+ 22;
9352 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9354 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9356 memcpy (digest
, tmp_buf
, 24);
9358 digest
[0] = byte_swap_32 (digest
[0]);
9359 digest
[1] = byte_swap_32 (digest
[1]);
9360 digest
[2] = byte_swap_32 (digest
[2]);
9361 digest
[3] = byte_swap_32 (digest
[3]);
9362 digest
[4] = byte_swap_32 (digest
[4]);
9363 digest
[5] = byte_swap_32 (digest
[5]);
9365 digest
[5] &= ~0xff; // its just 23 not 24 !
9370 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9372 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9374 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9378 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9380 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9382 memcpy (digest
, tmp_buf
, 32);
9384 digest
[0] = byte_swap_32 (digest
[0]);
9385 digest
[1] = byte_swap_32 (digest
[1]);
9386 digest
[2] = byte_swap_32 (digest
[2]);
9387 digest
[3] = byte_swap_32 (digest
[3]);
9388 digest
[4] = byte_swap_32 (digest
[4]);
9389 digest
[5] = byte_swap_32 (digest
[5]);
9390 digest
[6] = byte_swap_32 (digest
[6]);
9391 digest
[7] = byte_swap_32 (digest
[7]);
9393 digest
[0] -= SHA256M_A
;
9394 digest
[1] -= SHA256M_B
;
9395 digest
[2] -= SHA256M_C
;
9396 digest
[3] -= SHA256M_D
;
9397 digest
[4] -= SHA256M_E
;
9398 digest
[5] -= SHA256M_F
;
9399 digest
[6] -= SHA256M_G
;
9400 digest
[7] -= SHA256M_H
;
9405 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9407 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9409 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9411 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9412 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9414 digest
[0] = byte_swap_32 (digest
[0]);
9415 digest
[1] = byte_swap_32 (digest
[1]);
9419 IP (digest
[0], digest
[1], tt
);
9421 digest
[0] = digest
[0];
9422 digest
[1] = digest
[1];
9429 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9431 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9433 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9435 salt_t
*salt
= hash_buf
->salt
;
9437 char *hash_pos
= input_buf
+ 8;
9439 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9440 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9441 digest
[2] = hex_to_uint (&hash_pos
[16]);
9442 digest
[3] = hex_to_uint (&hash_pos
[24]);
9443 digest
[4] = hex_to_uint (&hash_pos
[32]);
9445 digest
[0] -= SHA1M_A
;
9446 digest
[1] -= SHA1M_B
;
9447 digest
[2] -= SHA1M_C
;
9448 digest
[3] -= SHA1M_D
;
9449 digest
[4] -= SHA1M_E
;
9453 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9455 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9457 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9459 salt
->salt_len
= salt_len
;
9464 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9466 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9468 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9470 salt_t
*salt
= hash_buf
->salt
;
9472 char *hash_pos
= input_buf
+ 8;
9474 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9475 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9476 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9477 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9478 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9479 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9480 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9481 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9483 digest
[0] -= SHA512M_A
;
9484 digest
[1] -= SHA512M_B
;
9485 digest
[2] -= SHA512M_C
;
9486 digest
[3] -= SHA512M_D
;
9487 digest
[4] -= SHA512M_E
;
9488 digest
[5] -= SHA512M_F
;
9489 digest
[6] -= SHA512M_G
;
9490 digest
[7] -= SHA512M_H
;
9494 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9496 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9498 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9500 salt
->salt_len
= salt_len
;
9505 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9507 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9509 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9513 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9516 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9518 salt_t
*salt
= hash_buf
->salt
;
9520 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9521 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9522 digest
[2] = hex_to_uint (&input_buf
[16]);
9523 digest
[3] = hex_to_uint (&input_buf
[24]);
9525 digest
[0] = byte_swap_32 (digest
[0]);
9526 digest
[1] = byte_swap_32 (digest
[1]);
9527 digest
[2] = byte_swap_32 (digest
[2]);
9528 digest
[3] = byte_swap_32 (digest
[3]);
9530 digest
[0] -= MD5M_A
;
9531 digest
[1] -= MD5M_B
;
9532 digest
[2] -= MD5M_C
;
9533 digest
[3] -= MD5M_D
;
9535 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9537 uint salt_len
= input_len
- 32 - 1;
9539 char *salt_buf
= input_buf
+ 32 + 1;
9541 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9543 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9545 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9547 salt
->salt_len
= salt_len
;
9552 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9554 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9556 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9560 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9565 char clean_input_buf
[32];
9567 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9568 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9570 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9574 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9580 clean_input_buf
[k
] = input_buf
[i
];
9588 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9590 salt_t
*salt
= hash_buf
->salt
;
9592 char a
, b
, c
, d
, e
, f
;
9594 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9595 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9596 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9597 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9598 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9599 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9601 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9602 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9604 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9605 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9606 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9607 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9608 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9609 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9611 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9612 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9614 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9615 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9616 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9617 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9618 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9619 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9621 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9622 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9624 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9625 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9626 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9627 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9628 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9629 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9631 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9632 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9634 digest
[0] = byte_swap_32 (digest
[0]);
9635 digest
[1] = byte_swap_32 (digest
[1]);
9636 digest
[2] = byte_swap_32 (digest
[2]);
9637 digest
[3] = byte_swap_32 (digest
[3]);
9639 digest
[0] -= MD5M_A
;
9640 digest
[1] -= MD5M_B
;
9641 digest
[2] -= MD5M_C
;
9642 digest
[3] -= MD5M_D
;
9644 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9646 uint salt_len
= input_len
- 30 - 1;
9648 char *salt_buf
= input_buf
+ 30 + 1;
9650 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9652 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9654 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9655 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9657 salt
->salt_len
= salt_len
;
9659 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9661 salt
->salt_len
+= 22;
9666 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9668 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9670 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9674 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9677 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9679 salt_t
*salt
= hash_buf
->salt
;
9681 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9682 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9683 digest
[2] = hex_to_uint (&input_buf
[16]);
9684 digest
[3] = hex_to_uint (&input_buf
[24]);
9685 digest
[4] = hex_to_uint (&input_buf
[32]);
9687 digest
[0] -= SHA1M_A
;
9688 digest
[1] -= SHA1M_B
;
9689 digest
[2] -= SHA1M_C
;
9690 digest
[3] -= SHA1M_D
;
9691 digest
[4] -= SHA1M_E
;
9693 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9695 uint salt_len
= input_len
- 40 - 1;
9697 char *salt_buf
= input_buf
+ 40 + 1;
9699 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9701 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9703 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9705 salt
->salt_len
= salt_len
;
9710 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9712 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9714 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9718 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9721 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9723 char *iter_pos
= input_buf
+ 6;
9725 salt_t
*salt
= hash_buf
->salt
;
9727 salt
->salt_iter
= atoi (iter_pos
) - 1;
9729 char *salt_pos
= strchr (iter_pos
, '#');
9731 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9735 char *digest_pos
= strchr (salt_pos
, '#');
9737 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9741 uint salt_len
= digest_pos
- salt_pos
- 1;
9743 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9745 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9746 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9747 digest
[2] = hex_to_uint (&digest_pos
[16]);
9748 digest
[3] = hex_to_uint (&digest_pos
[24]);
9750 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9752 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9754 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9756 salt
->salt_len
= salt_len
;
9761 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9763 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9765 salt_t
*salt
= hash_buf
->salt
;
9767 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9771 memcpy (&in
, input_buf
, input_len
);
9773 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9775 memcpy (digest
, in
.keymic
, 16);
9778 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9779 The phrase "Pairwise key expansion"
9780 Access Point Address (Referred to as Authenticator Address AA)
9781 Supplicant Address (referred to as Supplicant Address SA)
9782 Access Point Nonce (referred to as Authenticator Anonce)
9783 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9786 uint salt_len
= strlen (in
.essid
);
9788 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9790 salt
->salt_len
= salt_len
;
9792 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9794 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9796 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9798 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9800 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9801 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9805 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9806 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9809 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9811 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9812 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9816 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9817 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9820 for (int i
= 0; i
< 25; i
++)
9822 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9825 wpa
->keyver
= in
.keyver
;
9827 if (wpa
->keyver
> 255)
9829 log_info ("ATTENTION!");
9830 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9831 log_info (" This could be due to a recent aircrack-ng bug.");
9832 log_info (" The key version was automatically reset to a reasonable value.");
9835 wpa
->keyver
&= 0xff;
9838 wpa
->eapol_size
= in
.eapol_size
;
9840 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9842 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9844 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9846 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9848 if (wpa
->keyver
== 1)
9854 digest
[0] = byte_swap_32 (digest
[0]);
9855 digest
[1] = byte_swap_32 (digest
[1]);
9856 digest
[2] = byte_swap_32 (digest
[2]);
9857 digest
[3] = byte_swap_32 (digest
[3]);
9859 for (int i
= 0; i
< 64; i
++)
9861 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9865 salt
->salt_buf
[10] = digest
[1];
9866 salt
->salt_buf
[11] = digest
[2];
9871 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9873 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9875 salt_t
*salt
= hash_buf
->salt
;
9879 log_error ("Password Safe v2 container not specified");
9884 FILE *fp
= fopen (input_buf
, "rb");
9888 log_error ("%s: %s", input_buf
, strerror (errno
));
9897 uint32_t salt
[5]; // unused, but makes better valid check
9898 uint32_t iv
[2]; // unused, but makes better valid check
9904 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9908 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9910 salt
->salt_buf
[0] = buf
.random
[0];
9911 salt
->salt_buf
[1] = buf
.random
[1];
9914 salt
->salt_iter
= 1000;
9916 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9917 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9918 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9919 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9920 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9925 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9927 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9929 salt_t
*salt
= hash_buf
->salt
;
9933 log_error (".psafe3 not specified");
9938 FILE *fp
= fopen (input_buf
, "rb");
9942 log_error ("%s: %s", input_buf
, strerror (errno
));
9949 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9953 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9955 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9957 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9959 salt
->salt_iter
= in
.iterations
+ 1;
9961 salt
->salt_buf
[0] = in
.salt_buf
[0];
9962 salt
->salt_buf
[1] = in
.salt_buf
[1];
9963 salt
->salt_buf
[2] = in
.salt_buf
[2];
9964 salt
->salt_buf
[3] = in
.salt_buf
[3];
9965 salt
->salt_buf
[4] = in
.salt_buf
[4];
9966 salt
->salt_buf
[5] = in
.salt_buf
[5];
9967 salt
->salt_buf
[6] = in
.salt_buf
[6];
9968 salt
->salt_buf
[7] = in
.salt_buf
[7];
9970 salt
->salt_len
= 32;
9972 digest
[0] = in
.hash_buf
[0];
9973 digest
[1] = in
.hash_buf
[1];
9974 digest
[2] = in
.hash_buf
[2];
9975 digest
[3] = in
.hash_buf
[3];
9976 digest
[4] = in
.hash_buf
[4];
9977 digest
[5] = in
.hash_buf
[5];
9978 digest
[6] = in
.hash_buf
[6];
9979 digest
[7] = in
.hash_buf
[7];
9981 digest
[0] = byte_swap_32 (digest
[0]);
9982 digest
[1] = byte_swap_32 (digest
[1]);
9983 digest
[2] = byte_swap_32 (digest
[2]);
9984 digest
[3] = byte_swap_32 (digest
[3]);
9985 digest
[4] = byte_swap_32 (digest
[4]);
9986 digest
[5] = byte_swap_32 (digest
[5]);
9987 digest
[6] = byte_swap_32 (digest
[6]);
9988 digest
[7] = byte_swap_32 (digest
[7]);
9993 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9995 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
9997 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
9999 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10001 salt_t
*salt
= hash_buf
->salt
;
10003 char *iter_pos
= input_buf
+ 3;
10005 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10007 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10009 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10011 salt
->salt_iter
= salt_iter
;
10013 char *salt_pos
= iter_pos
+ 1;
10017 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10019 salt
->salt_len
= salt_len
;
10021 char *hash_pos
= salt_pos
+ salt_len
;
10023 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10025 return (PARSER_OK
);
10028 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10030 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10032 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10034 salt_t
*salt
= hash_buf
->salt
;
10036 char *salt_pos
= input_buf
+ 3;
10038 uint iterations_len
= 0;
10040 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10044 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10046 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10047 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10051 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10055 iterations_len
+= 8;
10059 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10062 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10064 char *hash_pos
= strchr (salt_pos
, '$');
10066 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10068 uint salt_len
= hash_pos
- salt_pos
;
10070 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10072 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10074 salt
->salt_len
= salt_len
;
10078 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10080 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10082 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10084 return (PARSER_OK
);
10087 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10089 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10091 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10093 salt_t
*salt
= hash_buf
->salt
;
10095 char *salt_pos
= input_buf
+ 6;
10097 uint iterations_len
= 0;
10099 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10103 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10105 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10106 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10110 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10114 iterations_len
+= 8;
10118 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10121 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10123 char *hash_pos
= strchr (salt_pos
, '$');
10125 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10127 uint salt_len
= hash_pos
- salt_pos
;
10129 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10131 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10133 salt
->salt_len
= salt_len
;
10137 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10139 return (PARSER_OK
);
10142 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10144 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10146 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10148 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10150 salt_t
*salt
= hash_buf
->salt
;
10152 char *salt_pos
= input_buf
+ 14;
10154 char *hash_pos
= strchr (salt_pos
, '*');
10156 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10160 uint salt_len
= hash_pos
- salt_pos
- 1;
10162 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10164 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10166 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10168 salt
->salt_len
= salt_len
;
10170 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10172 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10174 memcpy (digest
, tmp_buf
, 20);
10176 digest
[0] = byte_swap_32 (digest
[0]);
10177 digest
[1] = byte_swap_32 (digest
[1]);
10178 digest
[2] = byte_swap_32 (digest
[2]);
10179 digest
[3] = byte_swap_32 (digest
[3]);
10180 digest
[4] = byte_swap_32 (digest
[4]);
10182 digest
[0] -= SHA1M_A
;
10183 digest
[1] -= SHA1M_B
;
10184 digest
[2] -= SHA1M_C
;
10185 digest
[3] -= SHA1M_D
;
10186 digest
[4] -= SHA1M_E
;
10188 return (PARSER_OK
);
10191 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10193 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10195 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10197 if (c12
& 3) return (PARSER_HASH_VALUE
);
10199 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10201 salt_t
*salt
= hash_buf
->salt
;
10203 // for ascii_digest
10204 salt
->salt_sign
[0] = input_buf
[0];
10205 salt
->salt_sign
[1] = input_buf
[1];
10207 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10208 | itoa64_to_int (input_buf
[1]) << 6;
10210 salt
->salt_len
= 2;
10214 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10216 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10218 memcpy (digest
, tmp_buf
, 8);
10222 IP (digest
[0], digest
[1], tt
);
10227 return (PARSER_OK
);
10230 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10232 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10234 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10236 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10237 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10238 digest
[2] = hex_to_uint (&input_buf
[16]);
10239 digest
[3] = hex_to_uint (&input_buf
[24]);
10241 digest
[0] = byte_swap_32 (digest
[0]);
10242 digest
[1] = byte_swap_32 (digest
[1]);
10243 digest
[2] = byte_swap_32 (digest
[2]);
10244 digest
[3] = byte_swap_32 (digest
[3]);
10246 digest
[0] -= MD4M_A
;
10247 digest
[1] -= MD4M_B
;
10248 digest
[2] -= MD4M_C
;
10249 digest
[3] -= MD4M_D
;
10251 return (PARSER_OK
);
10254 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10256 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10258 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10262 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10265 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10267 salt_t
*salt
= hash_buf
->salt
;
10269 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10270 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10271 digest
[2] = hex_to_uint (&input_buf
[16]);
10272 digest
[3] = hex_to_uint (&input_buf
[24]);
10274 digest
[0] = byte_swap_32 (digest
[0]);
10275 digest
[1] = byte_swap_32 (digest
[1]);
10276 digest
[2] = byte_swap_32 (digest
[2]);
10277 digest
[3] = byte_swap_32 (digest
[3]);
10279 digest
[0] -= MD4M_A
;
10280 digest
[1] -= MD4M_B
;
10281 digest
[2] -= MD4M_C
;
10282 digest
[3] -= MD4M_D
;
10284 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10286 uint salt_len
= input_len
- 32 - 1;
10288 char *salt_buf
= input_buf
+ 32 + 1;
10290 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10292 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10294 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10296 salt
->salt_len
= salt_len
;
10298 return (PARSER_OK
);
10301 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10303 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10305 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10307 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10308 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10309 digest
[2] = hex_to_uint (&input_buf
[16]);
10310 digest
[3] = hex_to_uint (&input_buf
[24]);
10312 digest
[0] = byte_swap_32 (digest
[0]);
10313 digest
[1] = byte_swap_32 (digest
[1]);
10314 digest
[2] = byte_swap_32 (digest
[2]);
10315 digest
[3] = byte_swap_32 (digest
[3]);
10317 digest
[0] -= MD5M_A
;
10318 digest
[1] -= MD5M_B
;
10319 digest
[2] -= MD5M_C
;
10320 digest
[3] -= MD5M_D
;
10322 return (PARSER_OK
);
10325 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10327 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10329 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10331 digest
[0] = hex_to_uint (&input_buf
[0]);
10332 digest
[1] = hex_to_uint (&input_buf
[8]);
10336 digest
[0] = byte_swap_32 (digest
[0]);
10337 digest
[1] = byte_swap_32 (digest
[1]);
10339 return (PARSER_OK
);
10342 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10344 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10346 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10350 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10353 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10355 salt_t
*salt
= hash_buf
->salt
;
10357 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10358 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10359 digest
[2] = hex_to_uint (&input_buf
[16]);
10360 digest
[3] = hex_to_uint (&input_buf
[24]);
10362 digest
[0] = byte_swap_32 (digest
[0]);
10363 digest
[1] = byte_swap_32 (digest
[1]);
10364 digest
[2] = byte_swap_32 (digest
[2]);
10365 digest
[3] = byte_swap_32 (digest
[3]);
10367 digest
[0] -= MD5M_A
;
10368 digest
[1] -= MD5M_B
;
10369 digest
[2] -= MD5M_C
;
10370 digest
[3] -= MD5M_D
;
10372 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10374 uint salt_len
= input_len
- 32 - 1;
10376 char *salt_buf
= input_buf
+ 32 + 1;
10378 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10380 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10382 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10384 salt
->salt_len
= salt_len
;
10386 return (PARSER_OK
);
10389 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10391 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10393 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10395 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10396 | itoa64_to_int (input_buf
[ 1]) << 6
10397 | itoa64_to_int (input_buf
[ 2]) << 12
10398 | itoa64_to_int (input_buf
[ 3]) << 18;
10399 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10400 | itoa64_to_int (input_buf
[ 5]) << 6
10401 | itoa64_to_int (input_buf
[ 6]) << 12
10402 | itoa64_to_int (input_buf
[ 7]) << 18;
10403 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10404 | itoa64_to_int (input_buf
[ 9]) << 6
10405 | itoa64_to_int (input_buf
[10]) << 12
10406 | itoa64_to_int (input_buf
[11]) << 18;
10407 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10408 | itoa64_to_int (input_buf
[13]) << 6
10409 | itoa64_to_int (input_buf
[14]) << 12
10410 | itoa64_to_int (input_buf
[15]) << 18;
10412 digest
[0] -= MD5M_A
;
10413 digest
[1] -= MD5M_B
;
10414 digest
[2] -= MD5M_C
;
10415 digest
[3] -= MD5M_D
;
10417 digest
[0] &= 0x00ffffff;
10418 digest
[1] &= 0x00ffffff;
10419 digest
[2] &= 0x00ffffff;
10420 digest
[3] &= 0x00ffffff;
10422 return (PARSER_OK
);
10425 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10427 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10429 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10433 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10436 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10438 salt_t
*salt
= hash_buf
->salt
;
10440 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10441 | itoa64_to_int (input_buf
[ 1]) << 6
10442 | itoa64_to_int (input_buf
[ 2]) << 12
10443 | itoa64_to_int (input_buf
[ 3]) << 18;
10444 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10445 | itoa64_to_int (input_buf
[ 5]) << 6
10446 | itoa64_to_int (input_buf
[ 6]) << 12
10447 | itoa64_to_int (input_buf
[ 7]) << 18;
10448 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10449 | itoa64_to_int (input_buf
[ 9]) << 6
10450 | itoa64_to_int (input_buf
[10]) << 12
10451 | itoa64_to_int (input_buf
[11]) << 18;
10452 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10453 | itoa64_to_int (input_buf
[13]) << 6
10454 | itoa64_to_int (input_buf
[14]) << 12
10455 | itoa64_to_int (input_buf
[15]) << 18;
10457 digest
[0] -= MD5M_A
;
10458 digest
[1] -= MD5M_B
;
10459 digest
[2] -= MD5M_C
;
10460 digest
[3] -= MD5M_D
;
10462 digest
[0] &= 0x00ffffff;
10463 digest
[1] &= 0x00ffffff;
10464 digest
[2] &= 0x00ffffff;
10465 digest
[3] &= 0x00ffffff;
10467 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10469 uint salt_len
= input_len
- 16 - 1;
10471 char *salt_buf
= input_buf
+ 16 + 1;
10473 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10475 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10477 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10479 salt
->salt_len
= salt_len
;
10481 return (PARSER_OK
);
10484 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10486 key
[0] = (nthash
[0] >> 0);
10487 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10488 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10489 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10490 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10491 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10492 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10493 key
[7] = (nthash
[6] << 1);
10505 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10507 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10509 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10511 salt_t
*salt
= hash_buf
->salt
;
10513 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10519 char *user_pos
= input_buf
;
10521 char *unused_pos
= strchr (user_pos
, ':');
10523 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10525 uint user_len
= unused_pos
- user_pos
;
10527 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10531 char *domain_pos
= strchr (unused_pos
, ':');
10533 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10535 uint unused_len
= domain_pos
- unused_pos
;
10537 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10541 char *srvchall_pos
= strchr (domain_pos
, ':');
10543 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10545 uint domain_len
= srvchall_pos
- domain_pos
;
10547 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10551 char *hash_pos
= strchr (srvchall_pos
, ':');
10553 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10555 uint srvchall_len
= hash_pos
- srvchall_pos
;
10557 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10561 char *clichall_pos
= strchr (hash_pos
, ':');
10563 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10565 uint hash_len
= clichall_pos
- hash_pos
;
10567 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10571 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10573 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10576 * store some data for later use
10579 netntlm
->user_len
= user_len
* 2;
10580 netntlm
->domain_len
= domain_len
* 2;
10581 netntlm
->srvchall_len
= srvchall_len
/ 2;
10582 netntlm
->clichall_len
= clichall_len
/ 2;
10584 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10585 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10588 * handle username and domainname
10591 for (uint i
= 0; i
< user_len
; i
++)
10593 *userdomain_ptr
++ = user_pos
[i
];
10594 *userdomain_ptr
++ = 0;
10597 for (uint i
= 0; i
< domain_len
; i
++)
10599 *userdomain_ptr
++ = domain_pos
[i
];
10600 *userdomain_ptr
++ = 0;
10604 * handle server challenge encoding
10607 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10609 const char p0
= srvchall_pos
[i
+ 0];
10610 const char p1
= srvchall_pos
[i
+ 1];
10612 *chall_ptr
++ = hex_convert (p1
) << 0
10613 | hex_convert (p0
) << 4;
10617 * handle client challenge encoding
10620 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10622 const char p0
= clichall_pos
[i
+ 0];
10623 const char p1
= clichall_pos
[i
+ 1];
10625 *chall_ptr
++ = hex_convert (p1
) << 0
10626 | hex_convert (p0
) << 4;
10633 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10635 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10637 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10639 salt
->salt_len
= salt_len
;
10641 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10642 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10643 digest
[2] = hex_to_uint (&hash_pos
[16]);
10644 digest
[3] = hex_to_uint (&hash_pos
[24]);
10646 digest
[0] = byte_swap_32 (digest
[0]);
10647 digest
[1] = byte_swap_32 (digest
[1]);
10648 digest
[2] = byte_swap_32 (digest
[2]);
10649 digest
[3] = byte_swap_32 (digest
[3]);
10651 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10653 uint digest_tmp
[2];
10655 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10656 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10658 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10659 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10661 /* special case 2: ESS */
10663 if (srvchall_len
== 48)
10665 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10669 w
[ 0] = netntlm
->chall_buf
[6];
10670 w
[ 1] = netntlm
->chall_buf
[7];
10671 w
[ 2] = netntlm
->chall_buf
[0];
10672 w
[ 3] = netntlm
->chall_buf
[1];
10695 salt
->salt_buf
[0] = dgst
[0];
10696 salt
->salt_buf
[1] = dgst
[1];
10700 /* precompute netntlmv1 exploit start */
10702 for (uint i
= 0; i
< 0x10000; i
++)
10704 uint key_md4
[2] = { i
, 0 };
10705 uint key_des
[2] = { 0, 0 };
10707 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10712 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10714 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10716 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10718 if (data3
[0] != digest_tmp
[0]) continue;
10719 if (data3
[1] != digest_tmp
[1]) continue;
10721 salt
->salt_buf
[2] = i
;
10723 salt
->salt_len
= 24;
10728 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10729 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10731 /* precompute netntlmv1 exploit stop */
10735 IP (digest
[0], digest
[1], tt
);
10736 IP (digest
[2], digest
[3], tt
);
10738 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10739 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10740 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10741 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10743 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10745 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10746 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10748 return (PARSER_OK
);
10751 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10753 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10755 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10757 salt_t
*salt
= hash_buf
->salt
;
10759 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10765 char *user_pos
= input_buf
;
10767 char *unused_pos
= strchr (user_pos
, ':');
10769 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10771 uint user_len
= unused_pos
- user_pos
;
10773 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10777 char *domain_pos
= strchr (unused_pos
, ':');
10779 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10781 uint unused_len
= domain_pos
- unused_pos
;
10783 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10787 char *srvchall_pos
= strchr (domain_pos
, ':');
10789 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10791 uint domain_len
= srvchall_pos
- domain_pos
;
10793 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10797 char *hash_pos
= strchr (srvchall_pos
, ':');
10799 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10801 uint srvchall_len
= hash_pos
- srvchall_pos
;
10803 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10807 char *clichall_pos
= strchr (hash_pos
, ':');
10809 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10811 uint hash_len
= clichall_pos
- hash_pos
;
10813 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10817 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10819 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10821 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10824 * store some data for later use
10827 netntlm
->user_len
= user_len
* 2;
10828 netntlm
->domain_len
= domain_len
* 2;
10829 netntlm
->srvchall_len
= srvchall_len
/ 2;
10830 netntlm
->clichall_len
= clichall_len
/ 2;
10832 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10833 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10836 * handle username and domainname
10839 for (uint i
= 0; i
< user_len
; i
++)
10841 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10842 *userdomain_ptr
++ = 0;
10845 for (uint i
= 0; i
< domain_len
; i
++)
10847 *userdomain_ptr
++ = domain_pos
[i
];
10848 *userdomain_ptr
++ = 0;
10851 *userdomain_ptr
++ = 0x80;
10854 * handle server challenge encoding
10857 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10859 const char p0
= srvchall_pos
[i
+ 0];
10860 const char p1
= srvchall_pos
[i
+ 1];
10862 *chall_ptr
++ = hex_convert (p1
) << 0
10863 | hex_convert (p0
) << 4;
10867 * handle client challenge encoding
10870 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10872 const char p0
= clichall_pos
[i
+ 0];
10873 const char p1
= clichall_pos
[i
+ 1];
10875 *chall_ptr
++ = hex_convert (p1
) << 0
10876 | hex_convert (p0
) << 4;
10879 *chall_ptr
++ = 0x80;
10882 * handle hash itself
10885 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10886 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10887 digest
[2] = hex_to_uint (&hash_pos
[16]);
10888 digest
[3] = hex_to_uint (&hash_pos
[24]);
10890 digest
[0] = byte_swap_32 (digest
[0]);
10891 digest
[1] = byte_swap_32 (digest
[1]);
10892 digest
[2] = byte_swap_32 (digest
[2]);
10893 digest
[3] = byte_swap_32 (digest
[3]);
10896 * reuse challange data as salt_buf, its the buffer that is most likely unique
10899 salt
->salt_buf
[0] = 0;
10900 salt
->salt_buf
[1] = 0;
10901 salt
->salt_buf
[2] = 0;
10902 salt
->salt_buf
[3] = 0;
10903 salt
->salt_buf
[4] = 0;
10904 salt
->salt_buf
[5] = 0;
10905 salt
->salt_buf
[6] = 0;
10906 salt
->salt_buf
[7] = 0;
10910 uptr
= (uint
*) netntlm
->userdomain_buf
;
10912 for (uint i
= 0; i
< 16; i
+= 16)
10914 md5_64 (uptr
, salt
->salt_buf
);
10917 uptr
= (uint
*) netntlm
->chall_buf
;
10919 for (uint i
= 0; i
< 256; i
+= 16)
10921 md5_64 (uptr
, salt
->salt_buf
);
10924 salt
->salt_len
= 16;
10926 return (PARSER_OK
);
10929 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10931 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10933 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10937 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10940 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10942 salt_t
*salt
= hash_buf
->salt
;
10944 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10945 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10946 digest
[2] = hex_to_uint (&input_buf
[16]);
10947 digest
[3] = hex_to_uint (&input_buf
[24]);
10949 digest
[0] = byte_swap_32 (digest
[0]);
10950 digest
[1] = byte_swap_32 (digest
[1]);
10951 digest
[2] = byte_swap_32 (digest
[2]);
10952 digest
[3] = byte_swap_32 (digest
[3]);
10954 digest
[0] -= MD5M_A
;
10955 digest
[1] -= MD5M_B
;
10956 digest
[2] -= MD5M_C
;
10957 digest
[3] -= MD5M_D
;
10959 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10961 uint salt_len
= input_len
- 32 - 1;
10963 char *salt_buf
= input_buf
+ 32 + 1;
10965 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10967 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10969 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10971 salt
->salt_len
= salt_len
;
10973 return (PARSER_OK
);
10976 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10978 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10980 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10984 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
10987 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10989 salt_t
*salt
= hash_buf
->salt
;
10991 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10992 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10993 digest
[2] = hex_to_uint (&input_buf
[16]);
10994 digest
[3] = hex_to_uint (&input_buf
[24]);
10996 digest
[0] = byte_swap_32 (digest
[0]);
10997 digest
[1] = byte_swap_32 (digest
[1]);
10998 digest
[2] = byte_swap_32 (digest
[2]);
10999 digest
[3] = byte_swap_32 (digest
[3]);
11001 digest
[0] -= MD5M_A
;
11002 digest
[1] -= MD5M_B
;
11003 digest
[2] -= MD5M_C
;
11004 digest
[3] -= MD5M_D
;
11006 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11008 uint salt_len
= input_len
- 32 - 1;
11010 char *salt_buf
= input_buf
+ 32 + 1;
11012 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11014 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11016 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11018 salt
->salt_len
= salt_len
;
11020 return (PARSER_OK
);
11023 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11025 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11027 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11029 salt_t
*salt
= hash_buf
->salt
;
11031 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11032 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11033 digest
[2] = hex_to_uint (&input_buf
[16]);
11034 digest
[3] = hex_to_uint (&input_buf
[24]);
11036 digest
[0] = byte_swap_32 (digest
[0]);
11037 digest
[1] = byte_swap_32 (digest
[1]);
11038 digest
[2] = byte_swap_32 (digest
[2]);
11039 digest
[3] = byte_swap_32 (digest
[3]);
11041 digest
[0] -= MD5M_A
;
11042 digest
[1] -= MD5M_B
;
11043 digest
[2] -= MD5M_C
;
11044 digest
[3] -= MD5M_D
;
11047 * This is a virtual salt. While the algorithm is basically not salted
11048 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11049 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11052 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11054 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11056 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11058 salt
->salt_len
= salt_len
;
11060 return (PARSER_OK
);
11063 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11065 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11067 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11071 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11074 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11076 salt_t
*salt
= hash_buf
->salt
;
11078 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11079 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11080 digest
[2] = hex_to_uint (&input_buf
[16]);
11081 digest
[3] = hex_to_uint (&input_buf
[24]);
11083 digest
[0] = byte_swap_32 (digest
[0]);
11084 digest
[1] = byte_swap_32 (digest
[1]);
11085 digest
[2] = byte_swap_32 (digest
[2]);
11086 digest
[3] = byte_swap_32 (digest
[3]);
11088 digest
[0] -= MD5M_A
;
11089 digest
[1] -= MD5M_B
;
11090 digest
[2] -= MD5M_C
;
11091 digest
[3] -= MD5M_D
;
11093 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11095 uint salt_len
= input_len
- 32 - 1;
11097 char *salt_buf
= input_buf
+ 32 + 1;
11099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11101 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11103 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11105 salt
->salt_len
= salt_len
;
11107 return (PARSER_OK
);
11110 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11112 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11114 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11118 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11121 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11123 salt_t
*salt
= hash_buf
->salt
;
11125 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11126 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11127 digest
[2] = hex_to_uint (&input_buf
[16]);
11128 digest
[3] = hex_to_uint (&input_buf
[24]);
11130 digest
[0] = byte_swap_32 (digest
[0]);
11131 digest
[1] = byte_swap_32 (digest
[1]);
11132 digest
[2] = byte_swap_32 (digest
[2]);
11133 digest
[3] = byte_swap_32 (digest
[3]);
11135 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11137 uint salt_len
= input_len
- 32 - 1;
11139 char *salt_buf
= input_buf
+ 32 + 1;
11141 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11143 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11145 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11147 salt
->salt_len
= salt_len
;
11149 return (PARSER_OK
);
11152 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11154 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11156 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11160 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11163 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11165 salt_t
*salt
= hash_buf
->salt
;
11167 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11168 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11169 digest
[2] = hex_to_uint (&input_buf
[16]);
11170 digest
[3] = hex_to_uint (&input_buf
[24]);
11172 digest
[0] = byte_swap_32 (digest
[0]);
11173 digest
[1] = byte_swap_32 (digest
[1]);
11174 digest
[2] = byte_swap_32 (digest
[2]);
11175 digest
[3] = byte_swap_32 (digest
[3]);
11177 digest
[0] -= MD4M_A
;
11178 digest
[1] -= MD4M_B
;
11179 digest
[2] -= MD4M_C
;
11180 digest
[3] -= MD4M_D
;
11182 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11184 uint salt_len
= input_len
- 32 - 1;
11186 char *salt_buf
= input_buf
+ 32 + 1;
11188 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11190 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11192 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11194 salt
->salt_len
= salt_len
;
11196 return (PARSER_OK
);
11199 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11201 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11203 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11207 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11210 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11212 salt_t
*salt
= hash_buf
->salt
;
11214 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11215 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11216 digest
[2] = hex_to_uint (&input_buf
[16]);
11217 digest
[3] = hex_to_uint (&input_buf
[24]);
11219 digest
[0] = byte_swap_32 (digest
[0]);
11220 digest
[1] = byte_swap_32 (digest
[1]);
11221 digest
[2] = byte_swap_32 (digest
[2]);
11222 digest
[3] = byte_swap_32 (digest
[3]);
11224 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11226 uint salt_len
= input_len
- 32 - 1;
11228 char *salt_buf
= input_buf
+ 32 + 1;
11230 uint salt_pc_block
[16];
11232 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11234 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11236 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11238 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11240 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11242 salt_pc_block
[14] = salt_len
* 8;
11244 uint salt_pc_digest
[4];
11246 salt_pc_digest
[0] = MAGIC_A
;
11247 salt_pc_digest
[1] = MAGIC_B
;
11248 salt_pc_digest
[2] = MAGIC_C
;
11249 salt_pc_digest
[3] = MAGIC_D
;
11251 md5_64 (salt_pc_block
, salt_pc_digest
);
11253 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11254 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11255 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11256 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11258 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11260 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11262 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11264 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11265 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11266 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11267 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11269 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11271 return (PARSER_OK
);
11274 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11276 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11278 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11280 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11281 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11282 digest
[2] = hex_to_uint (&input_buf
[16]);
11283 digest
[3] = hex_to_uint (&input_buf
[24]);
11284 digest
[4] = hex_to_uint (&input_buf
[32]);
11286 digest
[0] -= SHA1M_A
;
11287 digest
[1] -= SHA1M_B
;
11288 digest
[2] -= SHA1M_C
;
11289 digest
[3] -= SHA1M_D
;
11290 digest
[4] -= SHA1M_E
;
11292 return (PARSER_OK
);
11295 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11297 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11299 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11301 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11302 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11303 digest
[2] = hex_to_uint (&input_buf
[16]);
11304 digest
[3] = hex_to_uint (&input_buf
[24]);
11305 digest
[4] = hex_to_uint (&input_buf
[32]);
11307 return (PARSER_OK
);
11310 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11312 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11314 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11318 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11321 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11323 salt_t
*salt
= hash_buf
->salt
;
11325 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11326 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11327 digest
[2] = hex_to_uint (&input_buf
[16]);
11328 digest
[3] = hex_to_uint (&input_buf
[24]);
11329 digest
[4] = hex_to_uint (&input_buf
[32]);
11331 digest
[0] -= SHA1M_A
;
11332 digest
[1] -= SHA1M_B
;
11333 digest
[2] -= SHA1M_C
;
11334 digest
[3] -= SHA1M_D
;
11335 digest
[4] -= SHA1M_E
;
11337 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11339 uint salt_len
= input_len
- 40 - 1;
11341 char *salt_buf
= input_buf
+ 40 + 1;
11343 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11349 salt
->salt_len
= salt_len
;
11351 return (PARSER_OK
);
11354 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11356 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11358 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11360 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11364 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11366 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11368 memcpy (digest
, tmp_buf
, 20);
11370 digest
[0] = byte_swap_32 (digest
[0]);
11371 digest
[1] = byte_swap_32 (digest
[1]);
11372 digest
[2] = byte_swap_32 (digest
[2]);
11373 digest
[3] = byte_swap_32 (digest
[3]);
11374 digest
[4] = byte_swap_32 (digest
[4]);
11376 digest
[0] -= SHA1M_A
;
11377 digest
[1] -= SHA1M_B
;
11378 digest
[2] -= SHA1M_C
;
11379 digest
[3] -= SHA1M_D
;
11380 digest
[4] -= SHA1M_E
;
11382 return (PARSER_OK
);
11385 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11387 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11389 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11391 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11393 salt_t
*salt
= hash_buf
->salt
;
11397 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11399 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11401 memcpy (digest
, tmp_buf
, 20);
11403 salt
->salt_len
= tmp_len
- 20;
11405 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11407 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11409 char *ptr
= (char *) salt
->salt_buf
;
11411 ptr
[salt
->salt_len
] = 0x80;
11414 digest
[0] = byte_swap_32 (digest
[0]);
11415 digest
[1] = byte_swap_32 (digest
[1]);
11416 digest
[2] = byte_swap_32 (digest
[2]);
11417 digest
[3] = byte_swap_32 (digest
[3]);
11418 digest
[4] = byte_swap_32 (digest
[4]);
11420 digest
[0] -= SHA1M_A
;
11421 digest
[1] -= SHA1M_B
;
11422 digest
[2] -= SHA1M_C
;
11423 digest
[3] -= SHA1M_D
;
11424 digest
[4] -= SHA1M_E
;
11426 return (PARSER_OK
);
11429 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11431 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11433 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11435 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11437 salt_t
*salt
= hash_buf
->salt
;
11439 char *salt_buf
= input_buf
+ 6;
11443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11449 salt
->salt_len
= salt_len
;
11451 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11453 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11454 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11455 digest
[2] = hex_to_uint (&hash_pos
[16]);
11456 digest
[3] = hex_to_uint (&hash_pos
[24]);
11457 digest
[4] = hex_to_uint (&hash_pos
[32]);
11459 digest
[0] -= SHA1M_A
;
11460 digest
[1] -= SHA1M_B
;
11461 digest
[2] -= SHA1M_C
;
11462 digest
[3] -= SHA1M_D
;
11463 digest
[4] -= SHA1M_E
;
11465 return (PARSER_OK
);
11468 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11470 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11472 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11474 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11476 salt_t
*salt
= hash_buf
->salt
;
11478 char *salt_buf
= input_buf
+ 6;
11482 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11484 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11486 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11488 salt
->salt_len
= salt_len
;
11490 char *hash_pos
= input_buf
+ 6 + 8;
11492 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11493 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11494 digest
[2] = hex_to_uint (&hash_pos
[16]);
11495 digest
[3] = hex_to_uint (&hash_pos
[24]);
11496 digest
[4] = hex_to_uint (&hash_pos
[32]);
11498 digest
[0] -= SHA1M_A
;
11499 digest
[1] -= SHA1M_B
;
11500 digest
[2] -= SHA1M_C
;
11501 digest
[3] -= SHA1M_D
;
11502 digest
[4] -= SHA1M_E
;
11504 return (PARSER_OK
);
11507 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11509 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11511 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11513 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11515 salt_t
*salt
= hash_buf
->salt
;
11517 char *salt_buf
= input_buf
+ 6;
11521 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11523 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11525 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11527 salt
->salt_len
= salt_len
;
11529 char *hash_pos
= input_buf
+ 6 + 8;
11531 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11532 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11533 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11534 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11535 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11536 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11537 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11538 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11540 digest
[0] -= SHA512M_A
;
11541 digest
[1] -= SHA512M_B
;
11542 digest
[2] -= SHA512M_C
;
11543 digest
[3] -= SHA512M_D
;
11544 digest
[4] -= SHA512M_E
;
11545 digest
[5] -= SHA512M_F
;
11546 digest
[6] -= SHA512M_G
;
11547 digest
[7] -= SHA512M_H
;
11549 return (PARSER_OK
);
11552 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11554 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11556 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11560 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11563 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11565 salt_t
*salt
= hash_buf
->salt
;
11567 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11568 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11572 digest
[0] = byte_swap_32 (digest
[0]);
11573 digest
[1] = byte_swap_32 (digest
[1]);
11575 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11577 uint salt_len
= input_len
- 16 - 1;
11579 char *salt_buf
= input_buf
+ 16 + 1;
11581 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11583 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11585 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11587 salt
->salt_len
= salt_len
;
11589 return (PARSER_OK
);
11592 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11594 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11596 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11598 salt_t
*salt
= hash_buf
->salt
;
11600 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11601 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11602 digest
[2] = hex_to_uint (&input_buf
[16]);
11603 digest
[3] = hex_to_uint (&input_buf
[24]);
11604 digest
[4] = hex_to_uint (&input_buf
[32]);
11606 digest
[0] -= SHA1M_A
;
11607 digest
[1] -= SHA1M_B
;
11608 digest
[2] -= SHA1M_C
;
11609 digest
[3] -= SHA1M_D
;
11610 digest
[4] -= SHA1M_E
;
11612 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11614 uint salt_len
= input_len
- 40 - 1;
11616 char *salt_buf
= input_buf
+ 40 + 1;
11618 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11620 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11622 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11624 salt
->salt_len
= salt_len
;
11626 return (PARSER_OK
);
11629 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11631 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11633 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11635 salt_t
*salt
= hash_buf
->salt
;
11637 char *hash_pos
= input_buf
;
11639 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11640 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11641 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11642 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11643 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11644 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11645 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11646 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11647 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11648 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11649 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11650 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11651 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11652 digest
[13] = hex_to_uint (&hash_pos
[104]);
11653 digest
[14] = hex_to_uint (&hash_pos
[112]);
11654 digest
[15] = hex_to_uint (&hash_pos
[120]);
11656 char *salt_pos
= input_buf
+ 128;
11658 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11659 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11660 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11661 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11663 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11664 salt
->salt_len
= 16;
11666 return (PARSER_OK
);
11669 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11671 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11673 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11675 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11676 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11677 digest
[2] = hex_to_uint (&input_buf
[16]);
11678 digest
[3] = hex_to_uint (&input_buf
[24]);
11679 digest
[4] = hex_to_uint (&input_buf
[32]);
11680 digest
[5] = hex_to_uint (&input_buf
[40]);
11681 digest
[6] = hex_to_uint (&input_buf
[48]);
11682 digest
[7] = hex_to_uint (&input_buf
[56]);
11684 digest
[0] -= SHA256M_A
;
11685 digest
[1] -= SHA256M_B
;
11686 digest
[2] -= SHA256M_C
;
11687 digest
[3] -= SHA256M_D
;
11688 digest
[4] -= SHA256M_E
;
11689 digest
[5] -= SHA256M_F
;
11690 digest
[6] -= SHA256M_G
;
11691 digest
[7] -= SHA256M_H
;
11693 return (PARSER_OK
);
11696 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11698 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11700 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11704 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11707 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11709 salt_t
*salt
= hash_buf
->salt
;
11711 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11712 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11713 digest
[2] = hex_to_uint (&input_buf
[16]);
11714 digest
[3] = hex_to_uint (&input_buf
[24]);
11715 digest
[4] = hex_to_uint (&input_buf
[32]);
11716 digest
[5] = hex_to_uint (&input_buf
[40]);
11717 digest
[6] = hex_to_uint (&input_buf
[48]);
11718 digest
[7] = hex_to_uint (&input_buf
[56]);
11720 digest
[0] -= SHA256M_A
;
11721 digest
[1] -= SHA256M_B
;
11722 digest
[2] -= SHA256M_C
;
11723 digest
[3] -= SHA256M_D
;
11724 digest
[4] -= SHA256M_E
;
11725 digest
[5] -= SHA256M_F
;
11726 digest
[6] -= SHA256M_G
;
11727 digest
[7] -= SHA256M_H
;
11729 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11731 uint salt_len
= input_len
- 64 - 1;
11733 char *salt_buf
= input_buf
+ 64 + 1;
11735 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11737 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11739 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11741 salt
->salt_len
= salt_len
;
11743 return (PARSER_OK
);
11746 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11748 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11750 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11752 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11753 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11754 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11755 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11756 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11757 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11761 digest
[0] -= SHA384M_A
;
11762 digest
[1] -= SHA384M_B
;
11763 digest
[2] -= SHA384M_C
;
11764 digest
[3] -= SHA384M_D
;
11765 digest
[4] -= SHA384M_E
;
11766 digest
[5] -= SHA384M_F
;
11770 return (PARSER_OK
);
11773 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11775 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11777 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11779 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11780 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11781 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11782 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11783 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11784 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11785 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11786 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11788 digest
[0] -= SHA512M_A
;
11789 digest
[1] -= SHA512M_B
;
11790 digest
[2] -= SHA512M_C
;
11791 digest
[3] -= SHA512M_D
;
11792 digest
[4] -= SHA512M_E
;
11793 digest
[5] -= SHA512M_F
;
11794 digest
[6] -= SHA512M_G
;
11795 digest
[7] -= SHA512M_H
;
11797 return (PARSER_OK
);
11800 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11802 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11804 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11808 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11811 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11813 salt_t
*salt
= hash_buf
->salt
;
11815 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11816 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11817 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11818 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11819 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11820 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11821 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11822 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11824 digest
[0] -= SHA512M_A
;
11825 digest
[1] -= SHA512M_B
;
11826 digest
[2] -= SHA512M_C
;
11827 digest
[3] -= SHA512M_D
;
11828 digest
[4] -= SHA512M_E
;
11829 digest
[5] -= SHA512M_F
;
11830 digest
[6] -= SHA512M_G
;
11831 digest
[7] -= SHA512M_H
;
11833 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11835 uint salt_len
= input_len
- 128 - 1;
11837 char *salt_buf
= input_buf
+ 128 + 1;
11839 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11841 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11843 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11845 salt
->salt_len
= salt_len
;
11847 return (PARSER_OK
);
11850 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11852 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11854 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11856 salt_t
*salt
= hash_buf
->salt
;
11858 char *salt_pos
= input_buf
+ 3;
11860 uint iterations_len
= 0;
11862 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11866 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11868 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11869 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11873 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11877 iterations_len
+= 8;
11881 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11884 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11886 char *hash_pos
= strchr (salt_pos
, '$');
11888 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11890 uint salt_len
= hash_pos
- salt_pos
;
11892 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11894 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11896 salt
->salt_len
= salt_len
;
11900 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11902 return (PARSER_OK
);
11905 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11907 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11909 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11911 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11913 salt_t
*salt
= hash_buf
->salt
;
11915 uint keccak_mdlen
= input_len
/ 2;
11917 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11919 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11921 digest
[i
] = byte_swap_64 (digest
[i
]);
11924 salt
->keccak_mdlen
= keccak_mdlen
;
11926 return (PARSER_OK
);
11929 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11931 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11933 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11935 salt_t
*salt
= hash_buf
->salt
;
11937 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11940 * Parse that strange long line
11947 in_off
[0] = strtok (input_buf
, ":");
11949 in_len
[0] = strlen (in_off
[0]);
11953 for (i
= 1; i
< 9; i
++)
11955 in_off
[i
] = strtok (NULL
, ":");
11957 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11959 in_len
[i
] = strlen (in_off
[i
]);
11964 ptr
= (char *) ikepsk
->msg_buf
;
11966 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11967 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11968 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11969 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11970 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11971 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11975 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11977 ptr
= (char *) ikepsk
->nr_buf
;
11979 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11980 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11984 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
11987 * Store to database
11992 digest
[0] = hex_to_uint (&ptr
[ 0]);
11993 digest
[1] = hex_to_uint (&ptr
[ 8]);
11994 digest
[2] = hex_to_uint (&ptr
[16]);
11995 digest
[3] = hex_to_uint (&ptr
[24]);
11997 digest
[0] = byte_swap_32 (digest
[0]);
11998 digest
[1] = byte_swap_32 (digest
[1]);
11999 digest
[2] = byte_swap_32 (digest
[2]);
12000 digest
[3] = byte_swap_32 (digest
[3]);
12002 salt
->salt_len
= 32;
12004 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12005 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12006 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12007 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12008 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12009 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12010 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12011 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12013 return (PARSER_OK
);
12016 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12018 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12020 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12022 salt_t
*salt
= hash_buf
->salt
;
12024 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12027 * Parse that strange long line
12034 in_off
[0] = strtok (input_buf
, ":");
12036 in_len
[0] = strlen (in_off
[0]);
12040 for (i
= 1; i
< 9; i
++)
12042 in_off
[i
] = strtok (NULL
, ":");
12044 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12046 in_len
[i
] = strlen (in_off
[i
]);
12051 ptr
= (char *) ikepsk
->msg_buf
;
12053 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12054 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12055 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12056 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12057 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12058 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12062 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12064 ptr
= (char *) ikepsk
->nr_buf
;
12066 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12067 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12071 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12074 * Store to database
12079 digest
[0] = hex_to_uint (&ptr
[ 0]);
12080 digest
[1] = hex_to_uint (&ptr
[ 8]);
12081 digest
[2] = hex_to_uint (&ptr
[16]);
12082 digest
[3] = hex_to_uint (&ptr
[24]);
12083 digest
[4] = hex_to_uint (&ptr
[32]);
12085 salt
->salt_len
= 32;
12087 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12088 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12089 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12090 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12091 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12092 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12093 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12094 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12096 return (PARSER_OK
);
12099 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12101 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12103 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12105 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12106 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12107 digest
[2] = hex_to_uint (&input_buf
[16]);
12108 digest
[3] = hex_to_uint (&input_buf
[24]);
12109 digest
[4] = hex_to_uint (&input_buf
[32]);
12111 digest
[0] = byte_swap_32 (digest
[0]);
12112 digest
[1] = byte_swap_32 (digest
[1]);
12113 digest
[2] = byte_swap_32 (digest
[2]);
12114 digest
[3] = byte_swap_32 (digest
[3]);
12115 digest
[4] = byte_swap_32 (digest
[4]);
12117 return (PARSER_OK
);
12120 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12122 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12124 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12126 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12127 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12128 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12129 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12130 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12131 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12132 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12133 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12134 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12135 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12136 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12137 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12138 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12139 digest
[13] = hex_to_uint (&input_buf
[104]);
12140 digest
[14] = hex_to_uint (&input_buf
[112]);
12141 digest
[15] = hex_to_uint (&input_buf
[120]);
12143 return (PARSER_OK
);
12146 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12148 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12150 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12152 salt_t
*salt
= hash_buf
->salt
;
12154 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12155 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12156 digest
[2] = hex_to_uint (&input_buf
[16]);
12157 digest
[3] = hex_to_uint (&input_buf
[24]);
12158 digest
[4] = hex_to_uint (&input_buf
[32]);
12160 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12162 uint salt_len
= input_len
- 40 - 1;
12164 char *salt_buf
= input_buf
+ 40 + 1;
12166 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12168 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12170 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12172 salt
->salt_len
= salt_len
;
12174 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12176 return (PARSER_OK
);
12179 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12181 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12183 salt_t
*salt
= hash_buf
->salt
;
12185 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12187 if (input_len
== 0)
12189 log_error ("TrueCrypt container not specified");
12194 FILE *fp
= fopen (input_buf
, "rb");
12198 log_error ("%s: %s", input_buf
, strerror (errno
));
12205 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12209 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12211 memcpy (tc
->salt_buf
, buf
, 64);
12213 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12215 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12217 salt
->salt_len
= 4;
12219 salt
->salt_iter
= 1000 - 1;
12221 digest
[0] = tc
->data_buf
[0];
12223 return (PARSER_OK
);
12226 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12228 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12230 salt_t
*salt
= hash_buf
->salt
;
12232 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12234 if (input_len
== 0)
12236 log_error ("TrueCrypt container not specified");
12241 FILE *fp
= fopen (input_buf
, "rb");
12245 log_error ("%s: %s", input_buf
, strerror (errno
));
12252 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12256 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12258 memcpy (tc
->salt_buf
, buf
, 64);
12260 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12262 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12264 salt
->salt_len
= 4;
12266 salt
->salt_iter
= 2000 - 1;
12268 digest
[0] = tc
->data_buf
[0];
12270 return (PARSER_OK
);
12273 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12275 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12277 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12279 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12281 salt_t
*salt
= hash_buf
->salt
;
12283 char *salt_pos
= input_buf
+ 6;
12285 char *hash_pos
= strchr (salt_pos
, '$');
12287 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12289 uint salt_len
= hash_pos
- salt_pos
;
12291 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12293 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12295 salt
->salt_len
= salt_len
;
12297 salt
->salt_iter
= 1000;
12301 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12303 return (PARSER_OK
);
12306 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12308 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12310 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12312 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12314 salt_t
*salt
= hash_buf
->salt
;
12316 char *iter_pos
= input_buf
+ 7;
12318 char *salt_pos
= strchr (iter_pos
, '$');
12320 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12324 char *hash_pos
= strchr (salt_pos
, '$');
12326 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12328 uint salt_len
= hash_pos
- salt_pos
;
12330 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12332 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12334 salt
->salt_len
= salt_len
;
12336 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12338 salt
->salt_sign
[0] = atoi (salt_iter
);
12340 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12344 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12346 digest
[0] = byte_swap_32 (digest
[0]);
12347 digest
[1] = byte_swap_32 (digest
[1]);
12348 digest
[2] = byte_swap_32 (digest
[2]);
12349 digest
[3] = byte_swap_32 (digest
[3]);
12350 digest
[4] = byte_swap_32 (digest
[4]);
12352 return (PARSER_OK
);
12355 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12357 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12359 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12361 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12363 salt_t
*salt
= hash_buf
->salt
;
12365 char *iter_pos
= input_buf
+ 9;
12367 char *salt_pos
= strchr (iter_pos
, '$');
12369 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12373 char *hash_pos
= strchr (salt_pos
, '$');
12375 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12377 uint salt_len
= hash_pos
- salt_pos
;
12379 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12381 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12383 salt
->salt_len
= salt_len
;
12385 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12387 salt
->salt_sign
[0] = atoi (salt_iter
);
12389 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12393 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12395 digest
[0] = byte_swap_32 (digest
[0]);
12396 digest
[1] = byte_swap_32 (digest
[1]);
12397 digest
[2] = byte_swap_32 (digest
[2]);
12398 digest
[3] = byte_swap_32 (digest
[3]);
12399 digest
[4] = byte_swap_32 (digest
[4]);
12400 digest
[5] = byte_swap_32 (digest
[5]);
12401 digest
[6] = byte_swap_32 (digest
[6]);
12402 digest
[7] = byte_swap_32 (digest
[7]);
12404 return (PARSER_OK
);
12407 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12409 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12411 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12413 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12415 salt_t
*salt
= hash_buf
->salt
;
12417 char *iter_pos
= input_buf
+ 9;
12419 char *salt_pos
= strchr (iter_pos
, '$');
12421 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12425 char *hash_pos
= strchr (salt_pos
, '$');
12427 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12429 uint salt_len
= hash_pos
- salt_pos
;
12431 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12433 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12435 salt
->salt_len
= salt_len
;
12437 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12439 salt
->salt_sign
[0] = atoi (salt_iter
);
12441 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12445 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12447 digest
[0] = byte_swap_64 (digest
[0]);
12448 digest
[1] = byte_swap_64 (digest
[1]);
12449 digest
[2] = byte_swap_64 (digest
[2]);
12450 digest
[3] = byte_swap_64 (digest
[3]);
12451 digest
[4] = byte_swap_64 (digest
[4]);
12452 digest
[5] = byte_swap_64 (digest
[5]);
12453 digest
[6] = byte_swap_64 (digest
[6]);
12454 digest
[7] = byte_swap_64 (digest
[7]);
12456 return (PARSER_OK
);
12459 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12461 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12463 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12465 salt_t
*salt
= hash_buf
->salt
;
12467 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12473 char *iterations_pos
= input_buf
;
12475 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12477 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12479 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12481 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12485 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12487 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12489 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12491 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12493 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12495 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12500 * pbkdf2 iterations
12503 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12506 * handle salt encoding
12509 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12511 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12513 const char p0
= saltbuf_pos
[i
+ 0];
12514 const char p1
= saltbuf_pos
[i
+ 1];
12516 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12517 | hex_convert (p0
) << 4;
12520 salt
->salt_len
= saltbuf_len
/ 2;
12523 * handle cipher encoding
12526 uint
*tmp
= (uint
*) mymalloc (32);
12528 char *cipherbuf_ptr
= (char *) tmp
;
12530 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12532 const char p0
= cipherbuf_pos
[i
+ 0];
12533 const char p1
= cipherbuf_pos
[i
+ 1];
12535 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12536 | hex_convert (p0
) << 4;
12539 // iv is stored at salt_buf 4 (length 16)
12540 // data is stored at salt_buf 8 (length 16)
12542 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12543 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12544 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12545 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12547 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12548 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12549 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12550 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12554 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12556 const char p0
= cipherbuf_pos
[j
+ 0];
12557 const char p1
= cipherbuf_pos
[j
+ 1];
12559 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12560 | hex_convert (p0
) << 4;
12567 digest
[0] = 0x10101010;
12568 digest
[1] = 0x10101010;
12569 digest
[2] = 0x10101010;
12570 digest
[3] = 0x10101010;
12572 return (PARSER_OK
);
12575 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12577 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12579 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12581 salt_t
*salt
= hash_buf
->salt
;
12583 char *hashbuf_pos
= input_buf
;
12585 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12587 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12589 uint hash_len
= iterations_pos
- hashbuf_pos
;
12591 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12595 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12597 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12599 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12603 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12605 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12609 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12611 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12613 salt
->salt_len
= salt_len
;
12615 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12617 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12618 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12619 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12620 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12622 return (PARSER_OK
);
12625 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12627 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12629 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12631 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12632 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12633 digest
[2] = hex_to_uint (&input_buf
[16]);
12634 digest
[3] = hex_to_uint (&input_buf
[24]);
12635 digest
[4] = hex_to_uint (&input_buf
[32]);
12636 digest
[5] = hex_to_uint (&input_buf
[40]);
12637 digest
[6] = hex_to_uint (&input_buf
[48]);
12638 digest
[7] = hex_to_uint (&input_buf
[56]);
12640 digest
[0] = byte_swap_32 (digest
[0]);
12641 digest
[1] = byte_swap_32 (digest
[1]);
12642 digest
[2] = byte_swap_32 (digest
[2]);
12643 digest
[3] = byte_swap_32 (digest
[3]);
12644 digest
[4] = byte_swap_32 (digest
[4]);
12645 digest
[5] = byte_swap_32 (digest
[5]);
12646 digest
[6] = byte_swap_32 (digest
[6]);
12647 digest
[7] = byte_swap_32 (digest
[7]);
12649 return (PARSER_OK
);
12652 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12654 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12656 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12658 salt_t
*salt
= hash_buf
->salt
;
12660 char *salt_pos
= input_buf
+ 3;
12662 uint iterations_len
= 0;
12664 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12668 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12670 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12671 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12675 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12679 iterations_len
+= 8;
12683 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12686 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12688 char *hash_pos
= strchr (salt_pos
, '$');
12690 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12692 uint salt_len
= hash_pos
- salt_pos
;
12694 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12696 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12698 salt
->salt_len
= salt_len
;
12702 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12704 return (PARSER_OK
);
12707 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12709 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12711 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12713 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12715 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12717 salt_t
*salt
= hash_buf
->salt
;
12719 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12721 char *iter_pos
= input_buf
+ 4;
12723 char *salt_pos
= strchr (iter_pos
, '$');
12725 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12729 char *hash_pos
= strchr (salt_pos
, '$');
12731 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12733 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12737 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12738 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12739 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12740 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12741 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12742 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12743 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12744 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12746 uint salt_len
= hash_pos
- salt_pos
- 1;
12748 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12750 salt
->salt_len
= salt_len
/ 2;
12752 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12753 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12754 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12755 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12756 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12757 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12758 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12759 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12761 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12762 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12763 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12764 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12765 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12766 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12767 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12768 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12769 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12770 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12772 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12774 salt
->salt_iter
= atoi (iter_pos
) - 1;
12776 return (PARSER_OK
);
12779 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12781 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12783 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12785 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12787 salt_t
*salt
= hash_buf
->salt
;
12789 char *salt_pos
= input_buf
+ 14;
12791 char *hash_pos
= strchr (salt_pos
, '*');
12793 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12797 uint salt_len
= hash_pos
- salt_pos
- 1;
12799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12801 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12803 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12805 salt
->salt_len
= salt_len
;
12807 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12809 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12811 memcpy (digest
, tmp_buf
, 32);
12813 digest
[0] = byte_swap_32 (digest
[0]);
12814 digest
[1] = byte_swap_32 (digest
[1]);
12815 digest
[2] = byte_swap_32 (digest
[2]);
12816 digest
[3] = byte_swap_32 (digest
[3]);
12817 digest
[4] = byte_swap_32 (digest
[4]);
12818 digest
[5] = byte_swap_32 (digest
[5]);
12819 digest
[6] = byte_swap_32 (digest
[6]);
12820 digest
[7] = byte_swap_32 (digest
[7]);
12822 digest
[0] -= SHA256M_A
;
12823 digest
[1] -= SHA256M_B
;
12824 digest
[2] -= SHA256M_C
;
12825 digest
[3] -= SHA256M_D
;
12826 digest
[4] -= SHA256M_E
;
12827 digest
[5] -= SHA256M_F
;
12828 digest
[6] -= SHA256M_G
;
12829 digest
[7] -= SHA256M_H
;
12831 return (PARSER_OK
);
12834 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12836 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12838 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12840 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12842 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12844 salt_t
*salt
= hash_buf
->salt
;
12846 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12848 char *iter_pos
= input_buf
+ 19;
12850 char *salt_pos
= strchr (iter_pos
, '.');
12852 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12856 char *hash_pos
= strchr (salt_pos
, '.');
12858 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12860 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12864 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12865 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12866 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12867 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12868 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12869 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12870 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12871 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12873 uint salt_len
= hash_pos
- salt_pos
- 1;
12877 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12881 for (i
= 0; i
< salt_len
; i
++)
12883 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12886 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12887 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12889 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12891 salt
->salt_len
= salt_len
;
12893 salt
->salt_iter
= atoi (iter_pos
) - 1;
12895 return (PARSER_OK
);
12898 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12900 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12902 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12904 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12906 salt_t
*salt
= hash_buf
->salt
;
12910 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12912 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12914 memcpy (digest
, tmp_buf
, 64);
12916 digest
[0] = byte_swap_64 (digest
[0]);
12917 digest
[1] = byte_swap_64 (digest
[1]);
12918 digest
[2] = byte_swap_64 (digest
[2]);
12919 digest
[3] = byte_swap_64 (digest
[3]);
12920 digest
[4] = byte_swap_64 (digest
[4]);
12921 digest
[5] = byte_swap_64 (digest
[5]);
12922 digest
[6] = byte_swap_64 (digest
[6]);
12923 digest
[7] = byte_swap_64 (digest
[7]);
12925 digest
[0] -= SHA512M_A
;
12926 digest
[1] -= SHA512M_B
;
12927 digest
[2] -= SHA512M_C
;
12928 digest
[3] -= SHA512M_D
;
12929 digest
[4] -= SHA512M_E
;
12930 digest
[5] -= SHA512M_F
;
12931 digest
[6] -= SHA512M_G
;
12932 digest
[7] -= SHA512M_H
;
12934 salt
->salt_len
= tmp_len
- 64;
12936 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12938 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12940 char *ptr
= (char *) salt
->salt_buf
;
12942 ptr
[salt
->salt_len
] = 0x80;
12945 return (PARSER_OK
);
12948 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12950 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12952 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12956 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12959 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12961 salt_t
*salt
= hash_buf
->salt
;
12963 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12964 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12965 digest
[2] = hex_to_uint (&input_buf
[16]);
12966 digest
[3] = hex_to_uint (&input_buf
[24]);
12968 digest
[0] = byte_swap_32 (digest
[0]);
12969 digest
[1] = byte_swap_32 (digest
[1]);
12970 digest
[2] = byte_swap_32 (digest
[2]);
12971 digest
[3] = byte_swap_32 (digest
[3]);
12973 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12975 uint salt_len
= input_len
- 32 - 1;
12977 char *salt_buf
= input_buf
+ 32 + 1;
12979 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12981 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12983 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12985 salt
->salt_len
= salt_len
;
12987 return (PARSER_OK
);
12990 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12992 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12994 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
12998 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13001 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13003 salt_t
*salt
= hash_buf
->salt
;
13005 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13006 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13007 digest
[2] = hex_to_uint (&input_buf
[16]);
13008 digest
[3] = hex_to_uint (&input_buf
[24]);
13009 digest
[4] = hex_to_uint (&input_buf
[32]);
13011 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13013 uint salt_len
= input_len
- 40 - 1;
13015 char *salt_buf
= input_buf
+ 40 + 1;
13017 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13019 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13021 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13023 salt
->salt_len
= salt_len
;
13025 return (PARSER_OK
);
13028 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13030 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13032 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13036 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13039 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13041 salt_t
*salt
= hash_buf
->salt
;
13043 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13044 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13045 digest
[2] = hex_to_uint (&input_buf
[16]);
13046 digest
[3] = hex_to_uint (&input_buf
[24]);
13047 digest
[4] = hex_to_uint (&input_buf
[32]);
13048 digest
[5] = hex_to_uint (&input_buf
[40]);
13049 digest
[6] = hex_to_uint (&input_buf
[48]);
13050 digest
[7] = hex_to_uint (&input_buf
[56]);
13052 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13054 uint salt_len
= input_len
- 64 - 1;
13056 char *salt_buf
= input_buf
+ 64 + 1;
13058 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13062 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13064 salt
->salt_len
= salt_len
;
13066 return (PARSER_OK
);
13069 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13071 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13073 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13077 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13080 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13082 salt_t
*salt
= hash_buf
->salt
;
13084 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13085 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13086 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13087 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13088 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13089 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13090 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13091 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13093 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13095 uint salt_len
= input_len
- 128 - 1;
13097 char *salt_buf
= input_buf
+ 128 + 1;
13099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13101 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13103 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13105 salt
->salt_len
= salt_len
;
13107 return (PARSER_OK
);
13110 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13112 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13114 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13116 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13118 salt_t
*salt
= hash_buf
->salt
;
13120 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13126 char *user_pos
= input_buf
+ 10 + 1;
13128 char *realm_pos
= strchr (user_pos
, '$');
13130 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13132 uint user_len
= realm_pos
- user_pos
;
13134 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13138 char *salt_pos
= strchr (realm_pos
, '$');
13140 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13142 uint realm_len
= salt_pos
- realm_pos
;
13144 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13148 char *data_pos
= strchr (salt_pos
, '$');
13150 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13152 uint salt_len
= data_pos
- salt_pos
;
13154 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13158 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13160 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13166 memcpy (krb5pa
->user
, user_pos
, user_len
);
13167 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13168 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13170 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13172 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13174 const char p0
= data_pos
[i
+ 0];
13175 const char p1
= data_pos
[i
+ 1];
13177 *timestamp_ptr
++ = hex_convert (p1
) << 0
13178 | hex_convert (p0
) << 4;
13181 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13183 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13185 const char p0
= data_pos
[i
+ 0];
13186 const char p1
= data_pos
[i
+ 1];
13188 *checksum_ptr
++ = hex_convert (p1
) << 0
13189 | hex_convert (p0
) << 4;
13193 * copy some data to generic buffers to make sorting happy
13196 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13197 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13198 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13199 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13200 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13201 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13202 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13203 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13204 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13206 salt
->salt_len
= 36;
13208 digest
[0] = krb5pa
->checksum
[0];
13209 digest
[1] = krb5pa
->checksum
[1];
13210 digest
[2] = krb5pa
->checksum
[2];
13211 digest
[3] = krb5pa
->checksum
[3];
13213 return (PARSER_OK
);
13216 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13218 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13220 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13222 salt_t
*salt
= hash_buf
->salt
;
13228 char *salt_pos
= input_buf
;
13230 char *hash_pos
= strchr (salt_pos
, '$');
13232 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13234 uint salt_len
= hash_pos
- salt_pos
;
13236 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13240 uint hash_len
= input_len
- 1 - salt_len
;
13242 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13250 for (uint i
= 0; i
< salt_len
; i
++)
13252 if (salt_pos
[i
] == ' ') continue;
13257 // SAP user names cannot be longer than 12 characters
13258 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13260 // SAP user name cannot start with ! or ?
13261 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13267 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13269 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13273 salt
->salt_len
= salt_len
;
13275 digest
[0] = hex_to_uint (&hash_pos
[0]);
13276 digest
[1] = hex_to_uint (&hash_pos
[8]);
13280 digest
[0] = byte_swap_32 (digest
[0]);
13281 digest
[1] = byte_swap_32 (digest
[1]);
13283 return (PARSER_OK
);
13286 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13288 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13290 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13292 salt_t
*salt
= hash_buf
->salt
;
13298 char *salt_pos
= input_buf
;
13300 char *hash_pos
= strchr (salt_pos
, '$');
13302 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13304 uint salt_len
= hash_pos
- salt_pos
;
13306 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13310 uint hash_len
= input_len
- 1 - salt_len
;
13312 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13320 for (uint i
= 0; i
< salt_len
; i
++)
13322 if (salt_pos
[i
] == ' ') continue;
13327 // SAP user names cannot be longer than 12 characters
13328 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13329 // so far nobody complained so we stay with this because it helps in optimization
13330 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13332 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13334 // SAP user name cannot start with ! or ?
13335 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13343 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13345 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13347 salt
->salt_len
= salt_len
;
13349 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13350 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13351 digest
[2] = hex_to_uint (&hash_pos
[16]);
13352 digest
[3] = hex_to_uint (&hash_pos
[24]);
13353 digest
[4] = hex_to_uint (&hash_pos
[32]);
13355 return (PARSER_OK
);
13358 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13360 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13362 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13364 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13366 salt_t
*salt
= hash_buf
->salt
;
13368 char *iter_pos
= input_buf
+ 3;
13370 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13372 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13374 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13376 salt
->salt_iter
= salt_iter
;
13378 char *salt_pos
= iter_pos
+ 1;
13382 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13384 salt
->salt_len
= salt_len
;
13386 char *hash_pos
= salt_pos
+ salt_len
;
13388 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13392 char *tmp
= (char *) salt
->salt_buf_pc
;
13394 tmp
[0] = hash_pos
[42];
13398 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13399 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13400 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13401 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13407 return (PARSER_OK
);
13410 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13412 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13414 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13416 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13418 salt_t
*salt
= hash_buf
->salt
;
13420 char *salt_buf
= input_buf
+ 6;
13422 uint salt_len
= 16;
13424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13426 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13428 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13430 salt
->salt_len
= salt_len
;
13432 char *hash_pos
= input_buf
+ 6 + 16;
13434 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13435 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13436 digest
[2] = hex_to_uint (&hash_pos
[16]);
13437 digest
[3] = hex_to_uint (&hash_pos
[24]);
13438 digest
[4] = hex_to_uint (&hash_pos
[32]);
13439 digest
[5] = hex_to_uint (&hash_pos
[40]);
13440 digest
[6] = hex_to_uint (&hash_pos
[48]);
13441 digest
[7] = hex_to_uint (&hash_pos
[56]);
13443 return (PARSER_OK
);
13446 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13448 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13450 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13452 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13453 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13457 return (PARSER_OK
);
13460 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13462 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13464 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13466 salt_t
*salt
= hash_buf
->salt
;
13468 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13470 char *saltbuf_pos
= input_buf
;
13472 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13474 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13476 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13478 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13479 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13481 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13485 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13487 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13489 char *salt_ptr
= (char *) saltbuf_pos
;
13490 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13495 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13497 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13500 rakp_ptr
[j
] = 0x80;
13502 rakp
->salt_len
= j
;
13504 for (i
= 0; i
< 64; i
++)
13506 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13509 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13510 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13511 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13512 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13513 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13514 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13515 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13516 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13518 salt
->salt_len
= 32; // muss min. 32 haben
13520 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13521 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13522 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13523 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13524 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13526 return (PARSER_OK
);
13529 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13531 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13533 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13535 salt_t
*salt
= hash_buf
->salt
;
13537 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13539 char *salt_pos
= input_buf
+ 1;
13541 memcpy (salt
->salt_buf
, salt_pos
, 8);
13543 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13544 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13546 salt
->salt_len
= 8;
13548 char *hash_pos
= salt_pos
+ 8;
13550 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13551 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13552 digest
[2] = hex_to_uint (&hash_pos
[16]);
13553 digest
[3] = hex_to_uint (&hash_pos
[24]);
13554 digest
[4] = hex_to_uint (&hash_pos
[32]);
13556 digest
[0] -= SHA1M_A
;
13557 digest
[1] -= SHA1M_B
;
13558 digest
[2] -= SHA1M_C
;
13559 digest
[3] -= SHA1M_D
;
13560 digest
[4] -= SHA1M_E
;
13562 return (PARSER_OK
);
13565 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13567 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13569 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13571 salt_t
*salt
= hash_buf
->salt
;
13573 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13574 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13575 digest
[2] = hex_to_uint (&input_buf
[16]);
13576 digest
[3] = hex_to_uint (&input_buf
[24]);
13578 digest
[0] = byte_swap_32 (digest
[0]);
13579 digest
[1] = byte_swap_32 (digest
[1]);
13580 digest
[2] = byte_swap_32 (digest
[2]);
13581 digest
[3] = byte_swap_32 (digest
[3]);
13583 digest
[0] -= MD5M_A
;
13584 digest
[1] -= MD5M_B
;
13585 digest
[2] -= MD5M_C
;
13586 digest
[3] -= MD5M_D
;
13588 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13590 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13592 uint32_t *salt_buf
= salt
->salt_buf
;
13594 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13595 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13596 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13597 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13599 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13600 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13601 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13602 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13604 salt
->salt_len
= 16 + 1;
13606 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13608 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13610 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13612 return (PARSER_OK
);
13615 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13617 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13619 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13621 salt_t
*salt
= hash_buf
->salt
;
13623 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13629 char *hashbuf_pos
= input_buf
;
13631 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13633 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13635 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13637 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13641 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13643 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13645 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13647 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13651 char *databuf_pos
= strchr (iteration_pos
, ':');
13653 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13655 const uint iteration_len
= databuf_pos
- iteration_pos
;
13657 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13658 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13660 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13662 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13663 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13669 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13670 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13671 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13672 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13673 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13674 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13675 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13676 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13680 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13682 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13684 const char p0
= saltbuf_pos
[i
+ 0];
13685 const char p1
= saltbuf_pos
[i
+ 1];
13687 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13688 | hex_convert (p0
) << 4;
13691 salt
->salt_buf
[4] = 0x01000000;
13692 salt
->salt_buf
[5] = 0x80;
13694 salt
->salt_len
= saltbuf_len
/ 2;
13698 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13702 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13704 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13706 const char p0
= databuf_pos
[i
+ 0];
13707 const char p1
= databuf_pos
[i
+ 1];
13709 *databuf_ptr
++ = hex_convert (p1
) << 0
13710 | hex_convert (p0
) << 4;
13713 *databuf_ptr
++ = 0x80;
13715 for (uint i
= 0; i
< 512; i
++)
13717 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13720 cloudkey
->data_len
= databuf_len
/ 2;
13722 return (PARSER_OK
);
13725 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13727 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13729 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13731 salt_t
*salt
= hash_buf
->salt
;
13737 char *hashbuf_pos
= input_buf
;
13739 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13741 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13743 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13745 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13749 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13751 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13753 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13755 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13757 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13761 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13763 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13765 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13767 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13769 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13773 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13775 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13776 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13778 // ok, the plan for this algorithm is the following:
13779 // we have 2 salts here, the domain-name and a random salt
13780 // while both are used in the initial transformation,
13781 // only the random salt is used in the following iterations
13782 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13783 // and one that includes only the real salt (stored into salt_buf[]).
13784 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13786 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13788 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13790 memcpy (digest
, tmp_buf
, 20);
13792 digest
[0] = byte_swap_32 (digest
[0]);
13793 digest
[1] = byte_swap_32 (digest
[1]);
13794 digest
[2] = byte_swap_32 (digest
[2]);
13795 digest
[3] = byte_swap_32 (digest
[3]);
13796 digest
[4] = byte_swap_32 (digest
[4]);
13800 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13802 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13804 char *len_ptr
= NULL
;
13806 for (uint i
= 0; i
< domainbuf_len
; i
++)
13808 if (salt_buf_pc_ptr
[i
] == '.')
13810 len_ptr
= &salt_buf_pc_ptr
[i
];
13820 salt
->salt_buf_pc
[7] = domainbuf_len
;
13824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13826 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13828 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13830 salt
->salt_len
= salt_len
;
13834 salt
->salt_iter
= atoi (iteration_pos
);
13836 return (PARSER_OK
);
13839 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13841 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13843 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13845 salt_t
*salt
= hash_buf
->salt
;
13847 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13848 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13849 digest
[2] = hex_to_uint (&input_buf
[16]);
13850 digest
[3] = hex_to_uint (&input_buf
[24]);
13851 digest
[4] = hex_to_uint (&input_buf
[32]);
13853 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13855 uint salt_len
= input_len
- 40 - 1;
13857 char *salt_buf
= input_buf
+ 40 + 1;
13859 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13861 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13863 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13865 salt
->salt_len
= salt_len
;
13867 return (PARSER_OK
);
13870 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13872 const uint8_t ascii_to_ebcdic
[] =
13874 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13875 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13876 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13877 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13878 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13879 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13880 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13881 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13882 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13883 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13884 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13885 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13886 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13887 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13888 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13889 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13892 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13894 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13896 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13898 salt_t
*salt
= hash_buf
->salt
;
13900 char *salt_pos
= input_buf
+ 6 + 1;
13902 char *digest_pos
= strchr (salt_pos
, '*');
13904 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13906 uint salt_len
= digest_pos
- salt_pos
;
13908 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13910 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13912 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13916 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13917 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13919 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13921 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13923 salt
->salt_len
= salt_len
;
13925 for (uint i
= 0; i
< salt_len
; i
++)
13927 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13929 for (uint i
= salt_len
; i
< 8; i
++)
13931 salt_buf_pc_ptr
[i
] = 0x40;
13936 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13938 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13939 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13941 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13942 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13944 digest
[0] = byte_swap_32 (digest
[0]);
13945 digest
[1] = byte_swap_32 (digest
[1]);
13947 IP (digest
[0], digest
[1], tt
);
13949 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13950 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13954 return (PARSER_OK
);
13957 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13959 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13961 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13963 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13964 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13965 digest
[2] = hex_to_uint (&input_buf
[16]);
13966 digest
[3] = hex_to_uint (&input_buf
[24]);
13968 digest
[0] = byte_swap_32 (digest
[0]);
13969 digest
[1] = byte_swap_32 (digest
[1]);
13970 digest
[2] = byte_swap_32 (digest
[2]);
13971 digest
[3] = byte_swap_32 (digest
[3]);
13973 return (PARSER_OK
);
13976 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13978 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13980 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13982 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13984 salt_t
*salt
= hash_buf
->salt
;
13988 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13990 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13992 tmp_buf
[3] += -4; // dont ask!
13994 memcpy (salt
->salt_buf
, tmp_buf
, 5);
13996 salt
->salt_len
= 5;
13998 memcpy (digest
, tmp_buf
+ 5, 9);
14000 // yes, only 9 byte are needed to crack, but 10 to display
14002 salt
->salt_buf_pc
[7] = input_buf
[20];
14004 return (PARSER_OK
);
14007 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14009 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14011 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14013 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14015 salt_t
*salt
= hash_buf
->salt
;
14019 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14021 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14023 tmp_buf
[3] += -4; // dont ask!
14027 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14029 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)
14033 char tmp_iter_buf
[11];
14035 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14037 tmp_iter_buf
[10] = 0;
14039 salt
->salt_iter
= atoi (tmp_iter_buf
);
14041 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14043 return (PARSER_SALT_ITERATION
);
14046 salt
->salt_iter
--; // first round in init
14048 // 2 additional bytes for display only
14050 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14051 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14055 memcpy (digest
, tmp_buf
+ 28, 8);
14057 digest
[0] = byte_swap_32 (digest
[0]);
14058 digest
[1] = byte_swap_32 (digest
[1]);
14062 return (PARSER_OK
);
14065 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14067 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14069 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14071 salt_t
*salt
= hash_buf
->salt
;
14073 char *salt_buf_pos
= input_buf
;
14075 char *hash_buf_pos
= salt_buf_pos
+ 6;
14077 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14078 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14079 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14080 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14081 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14082 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14083 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14084 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14086 digest
[0] -= SHA256M_A
;
14087 digest
[1] -= SHA256M_B
;
14088 digest
[2] -= SHA256M_C
;
14089 digest
[3] -= SHA256M_D
;
14090 digest
[4] -= SHA256M_E
;
14091 digest
[5] -= SHA256M_F
;
14092 digest
[6] -= SHA256M_G
;
14093 digest
[7] -= SHA256M_H
;
14095 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14097 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14099 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14101 salt
->salt_len
= salt_len
;
14103 return (PARSER_OK
);
14106 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14108 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14110 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14112 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14114 salt_t
*salt
= hash_buf
->salt
;
14116 char *salt_buf
= input_buf
+ 6;
14118 char *digest_buf
= strchr (salt_buf
, '$');
14120 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14122 uint salt_len
= digest_buf
- salt_buf
;
14124 digest_buf
++; // skip the '$' symbol
14126 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14128 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14132 salt
->salt_len
= salt_len
;
14134 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14135 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14136 digest
[2] = hex_to_uint (&digest_buf
[16]);
14137 digest
[3] = hex_to_uint (&digest_buf
[24]);
14139 digest
[0] = byte_swap_32 (digest
[0]);
14140 digest
[1] = byte_swap_32 (digest
[1]);
14141 digest
[2] = byte_swap_32 (digest
[2]);
14142 digest
[3] = byte_swap_32 (digest
[3]);
14144 digest
[0] -= MD5M_A
;
14145 digest
[1] -= MD5M_B
;
14146 digest
[2] -= MD5M_C
;
14147 digest
[3] -= MD5M_D
;
14149 return (PARSER_OK
);
14152 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14154 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14156 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14158 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14160 salt_t
*salt
= hash_buf
->salt
;
14162 char *salt_buf
= input_buf
+ 3;
14164 char *digest_buf
= strchr (salt_buf
, '$');
14166 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14168 uint salt_len
= digest_buf
- salt_buf
;
14170 digest_buf
++; // skip the '$' symbol
14172 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14174 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14176 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14178 salt_buf_ptr
[salt_len
] = 0x2d;
14180 salt
->salt_len
= salt_len
+ 1;
14182 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14183 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14184 digest
[2] = hex_to_uint (&digest_buf
[16]);
14185 digest
[3] = hex_to_uint (&digest_buf
[24]);
14187 digest
[0] = byte_swap_32 (digest
[0]);
14188 digest
[1] = byte_swap_32 (digest
[1]);
14189 digest
[2] = byte_swap_32 (digest
[2]);
14190 digest
[3] = byte_swap_32 (digest
[3]);
14192 digest
[0] -= MD5M_A
;
14193 digest
[1] -= MD5M_B
;
14194 digest
[2] -= MD5M_C
;
14195 digest
[3] -= MD5M_D
;
14197 return (PARSER_OK
);
14200 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14202 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14204 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14208 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14210 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14212 memcpy (digest
, tmp_buf
, 20);
14214 digest
[0] = byte_swap_32 (digest
[0]);
14215 digest
[1] = byte_swap_32 (digest
[1]);
14216 digest
[2] = byte_swap_32 (digest
[2]);
14217 digest
[3] = byte_swap_32 (digest
[3]);
14218 digest
[4] = byte_swap_32 (digest
[4]);
14220 digest
[0] -= SHA1M_A
;
14221 digest
[1] -= SHA1M_B
;
14222 digest
[2] -= SHA1M_C
;
14223 digest
[3] -= SHA1M_D
;
14224 digest
[4] -= SHA1M_E
;
14226 return (PARSER_OK
);
14229 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14231 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14233 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14235 salt_t
*salt
= hash_buf
->salt
;
14237 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14238 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14239 digest
[2] = hex_to_uint (&input_buf
[16]);
14240 digest
[3] = hex_to_uint (&input_buf
[24]);
14242 digest
[0] = byte_swap_32 (digest
[0]);
14243 digest
[1] = byte_swap_32 (digest
[1]);
14244 digest
[2] = byte_swap_32 (digest
[2]);
14245 digest
[3] = byte_swap_32 (digest
[3]);
14247 digest
[0] -= MD5M_A
;
14248 digest
[1] -= MD5M_B
;
14249 digest
[2] -= MD5M_C
;
14250 digest
[3] -= MD5M_D
;
14252 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14254 uint salt_len
= input_len
- 32 - 1;
14256 char *salt_buf
= input_buf
+ 32 + 1;
14258 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14260 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14262 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14265 * add static "salt" part
14268 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14272 salt
->salt_len
= salt_len
;
14274 return (PARSER_OK
);
14277 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14279 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14281 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14283 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14285 salt_t
*salt
= hash_buf
->salt
;
14287 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14293 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14295 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14297 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14299 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14301 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14305 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14307 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14309 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14311 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14315 char *keybuf_pos
= strchr (keylen_pos
, '$');
14317 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14319 uint keylen_len
= keybuf_pos
- keylen_pos
;
14321 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14325 char *databuf_pos
= strchr (keybuf_pos
, '$');
14327 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14329 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14331 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14335 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14337 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14343 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14344 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14345 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14346 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14348 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14349 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14350 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14351 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14353 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14354 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14355 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14356 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14358 salt
->salt_len
= 16;
14359 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14361 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14363 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14366 return (PARSER_OK
);
14369 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14371 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14373 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14375 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14377 salt_t
*salt
= hash_buf
->salt
;
14383 // first is the N salt parameter
14385 char *N_pos
= input_buf
+ 6;
14387 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14391 salt
->scrypt_N
= atoi (N_pos
);
14395 char *r_pos
= strchr (N_pos
, ':');
14397 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14401 salt
->scrypt_r
= atoi (r_pos
);
14405 char *p_pos
= strchr (r_pos
, ':');
14407 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14411 salt
->scrypt_p
= atoi (p_pos
);
14415 char *saltbuf_pos
= strchr (p_pos
, ':');
14417 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14421 char *hash_pos
= strchr (saltbuf_pos
, ':');
14423 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14431 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14433 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14435 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14437 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14439 salt
->salt_len
= tmp_len
;
14440 salt
->salt_iter
= 1;
14442 // digest - base64 decode
14444 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14446 tmp_len
= input_len
- (hash_pos
- input_buf
);
14448 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14450 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14452 memcpy (digest
, tmp_buf
, 32);
14454 return (PARSER_OK
);
14457 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14459 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14461 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14463 salt_t
*salt
= hash_buf
->salt
;
14469 char decrypted
[76]; // iv + hash
14471 juniper_decrypt_hash (input_buf
, decrypted
);
14473 char *md5crypt_hash
= decrypted
+ 12;
14475 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14477 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14479 char *salt_pos
= md5crypt_hash
+ 3;
14481 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14483 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14485 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14489 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14491 return (PARSER_OK
);
14494 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14496 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14498 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14500 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14502 salt_t
*salt
= hash_buf
->salt
;
14504 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14510 // first is *raw* salt
14512 char *salt_pos
= input_buf
+ 3;
14514 char *hash_pos
= strchr (salt_pos
, '$');
14516 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14518 uint salt_len
= hash_pos
- salt_pos
;
14520 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14524 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14526 memcpy (salt_buf_ptr
, salt_pos
, 14);
14528 salt_buf_ptr
[17] = 0x01;
14529 salt_buf_ptr
[18] = 0x80;
14531 // add some stuff to normal salt to make sorted happy
14533 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14534 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14535 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14536 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14538 salt
->salt_len
= salt_len
;
14539 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14541 // base64 decode hash
14545 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14547 uint hash_len
= input_len
- 3 - salt_len
- 1;
14549 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14551 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14553 memcpy (digest
, tmp_buf
, 32);
14555 digest
[0] = byte_swap_32 (digest
[0]);
14556 digest
[1] = byte_swap_32 (digest
[1]);
14557 digest
[2] = byte_swap_32 (digest
[2]);
14558 digest
[3] = byte_swap_32 (digest
[3]);
14559 digest
[4] = byte_swap_32 (digest
[4]);
14560 digest
[5] = byte_swap_32 (digest
[5]);
14561 digest
[6] = byte_swap_32 (digest
[6]);
14562 digest
[7] = byte_swap_32 (digest
[7]);
14564 return (PARSER_OK
);
14567 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14569 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14571 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14573 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14575 salt_t
*salt
= hash_buf
->salt
;
14581 // first is *raw* salt
14583 char *salt_pos
= input_buf
+ 3;
14585 char *hash_pos
= strchr (salt_pos
, '$');
14587 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14589 uint salt_len
= hash_pos
- salt_pos
;
14591 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14593 salt
->salt_len
= salt_len
;
14596 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14598 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14599 salt_buf_ptr
[salt_len
] = 0;
14601 // base64 decode hash
14605 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14607 uint hash_len
= input_len
- 3 - salt_len
- 1;
14609 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14611 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14613 memcpy (digest
, tmp_buf
, 32);
14616 salt
->scrypt_N
= 16384;
14617 salt
->scrypt_r
= 1;
14618 salt
->scrypt_p
= 1;
14619 salt
->salt_iter
= 1;
14621 return (PARSER_OK
);
14624 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14626 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14628 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14630 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14632 salt_t
*salt
= hash_buf
->salt
;
14634 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14640 char *version_pos
= input_buf
+ 8 + 1;
14642 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14644 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14646 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14648 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14650 verifierHashSize_pos
++;
14652 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14654 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14656 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14658 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14662 char *saltSize_pos
= strchr (keySize_pos
, '*');
14664 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14666 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14668 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14672 char *osalt_pos
= strchr (saltSize_pos
, '*');
14674 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14676 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14678 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14682 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14684 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14686 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14688 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14690 encryptedVerifier_pos
++;
14692 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14694 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14696 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14698 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14700 encryptedVerifierHash_pos
++;
14702 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;
14704 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14706 const uint version
= atoi (version_pos
);
14708 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14710 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14712 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14714 const uint keySize
= atoi (keySize_pos
);
14716 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14718 office2007
->keySize
= keySize
;
14720 const uint saltSize
= atoi (saltSize_pos
);
14722 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14728 salt
->salt_len
= 16;
14729 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14731 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14732 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14733 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14734 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14740 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14741 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14742 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14743 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14745 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14746 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14747 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14748 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14749 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14755 digest
[0] = office2007
->encryptedVerifierHash
[0];
14756 digest
[1] = office2007
->encryptedVerifierHash
[1];
14757 digest
[2] = office2007
->encryptedVerifierHash
[2];
14758 digest
[3] = office2007
->encryptedVerifierHash
[3];
14760 return (PARSER_OK
);
14763 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14765 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14767 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14769 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14771 salt_t
*salt
= hash_buf
->salt
;
14773 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14779 char *version_pos
= input_buf
+ 8 + 1;
14781 char *spinCount_pos
= strchr (version_pos
, '*');
14783 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14785 uint32_t version_len
= spinCount_pos
- version_pos
;
14787 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14791 char *keySize_pos
= strchr (spinCount_pos
, '*');
14793 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14795 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14797 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14801 char *saltSize_pos
= strchr (keySize_pos
, '*');
14803 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14805 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14807 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14811 char *osalt_pos
= strchr (saltSize_pos
, '*');
14813 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14815 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14817 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14821 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14823 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14825 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14827 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14829 encryptedVerifier_pos
++;
14831 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14833 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14835 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14837 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14839 encryptedVerifierHash_pos
++;
14841 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;
14843 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14845 const uint version
= atoi (version_pos
);
14847 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14849 const uint spinCount
= atoi (spinCount_pos
);
14851 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14853 const uint keySize
= atoi (keySize_pos
);
14855 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14857 const uint saltSize
= atoi (saltSize_pos
);
14859 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14865 salt
->salt_len
= 16;
14866 salt
->salt_iter
= spinCount
;
14868 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14869 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14870 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14871 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14877 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14878 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14879 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14880 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14882 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14883 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14884 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14885 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14886 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14887 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14888 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14889 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14895 digest
[0] = office2010
->encryptedVerifierHash
[0];
14896 digest
[1] = office2010
->encryptedVerifierHash
[1];
14897 digest
[2] = office2010
->encryptedVerifierHash
[2];
14898 digest
[3] = office2010
->encryptedVerifierHash
[3];
14900 return (PARSER_OK
);
14903 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14905 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14907 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14909 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14911 salt_t
*salt
= hash_buf
->salt
;
14913 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14919 char *version_pos
= input_buf
+ 8 + 1;
14921 char *spinCount_pos
= strchr (version_pos
, '*');
14923 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14925 uint32_t version_len
= spinCount_pos
- version_pos
;
14927 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14931 char *keySize_pos
= strchr (spinCount_pos
, '*');
14933 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14935 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14937 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14941 char *saltSize_pos
= strchr (keySize_pos
, '*');
14943 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14945 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14947 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14951 char *osalt_pos
= strchr (saltSize_pos
, '*');
14953 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14955 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14957 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14961 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14963 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14965 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14967 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14969 encryptedVerifier_pos
++;
14971 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14973 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14975 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14977 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14979 encryptedVerifierHash_pos
++;
14981 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;
14983 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14985 const uint version
= atoi (version_pos
);
14987 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14989 const uint spinCount
= atoi (spinCount_pos
);
14991 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14993 const uint keySize
= atoi (keySize_pos
);
14995 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
14997 const uint saltSize
= atoi (saltSize_pos
);
14999 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15005 salt
->salt_len
= 16;
15006 salt
->salt_iter
= spinCount
;
15008 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15009 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15010 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15011 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15017 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15018 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15019 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15020 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15022 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15023 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15024 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15025 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15026 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15027 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15028 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15029 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15035 digest
[0] = office2013
->encryptedVerifierHash
[0];
15036 digest
[1] = office2013
->encryptedVerifierHash
[1];
15037 digest
[2] = office2013
->encryptedVerifierHash
[2];
15038 digest
[3] = office2013
->encryptedVerifierHash
[3];
15040 return (PARSER_OK
);
15043 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15045 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15047 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15049 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15051 salt_t
*salt
= hash_buf
->salt
;
15053 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15059 char *version_pos
= input_buf
+ 11;
15061 char *osalt_pos
= strchr (version_pos
, '*');
15063 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15065 uint32_t version_len
= osalt_pos
- version_pos
;
15067 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15071 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15073 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15075 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15077 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15079 encryptedVerifier_pos
++;
15081 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15083 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15085 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15087 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15089 encryptedVerifierHash_pos
++;
15091 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15093 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15095 const uint version
= *version_pos
- 0x30;
15097 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15103 oldoffice01
->version
= version
;
15105 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15106 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15107 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15108 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15110 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15111 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15112 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15113 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15115 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15116 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15117 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15118 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15120 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15121 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15122 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15123 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15129 salt
->salt_len
= 16;
15131 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15132 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15133 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15134 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15136 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15137 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15138 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15139 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15141 // this is a workaround as office produces multiple documents with the same salt
15143 salt
->salt_len
+= 32;
15145 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15146 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15147 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15148 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15149 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15150 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15151 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15152 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15158 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15159 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15160 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15161 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15163 return (PARSER_OK
);
15166 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15168 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15171 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15173 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15175 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15177 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15179 salt_t
*salt
= hash_buf
->salt
;
15181 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15187 char *version_pos
= input_buf
+ 11;
15189 char *osalt_pos
= strchr (version_pos
, '*');
15191 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15193 uint32_t version_len
= osalt_pos
- version_pos
;
15195 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15199 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15201 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15203 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15205 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15207 encryptedVerifier_pos
++;
15209 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15211 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15213 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15215 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15217 encryptedVerifierHash_pos
++;
15219 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15221 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15223 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15225 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15229 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15231 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15233 const uint version
= *version_pos
- 0x30;
15235 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15241 oldoffice01
->version
= version
;
15243 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15244 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15245 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15246 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15248 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15249 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15250 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15251 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15253 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15254 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15255 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15256 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15258 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15259 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15260 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15261 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15263 oldoffice01
->rc4key
[1] = 0;
15264 oldoffice01
->rc4key
[0] = 0;
15266 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15267 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15268 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15269 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15270 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15271 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15272 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15273 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15274 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15275 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15277 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15278 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15284 salt
->salt_len
= 16;
15286 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15287 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15288 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15289 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15291 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15292 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15293 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15294 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15296 // this is a workaround as office produces multiple documents with the same salt
15298 salt
->salt_len
+= 32;
15300 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15301 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15302 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15303 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15304 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15305 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15306 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15307 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15313 digest
[0] = oldoffice01
->rc4key
[0];
15314 digest
[1] = oldoffice01
->rc4key
[1];
15318 return (PARSER_OK
);
15321 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15323 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15325 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15327 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15329 salt_t
*salt
= hash_buf
->salt
;
15331 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15337 char *version_pos
= input_buf
+ 11;
15339 char *osalt_pos
= strchr (version_pos
, '*');
15341 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15343 uint32_t version_len
= osalt_pos
- version_pos
;
15345 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15349 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15351 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15353 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15355 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15357 encryptedVerifier_pos
++;
15359 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15361 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15363 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15365 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15367 encryptedVerifierHash_pos
++;
15369 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15371 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15373 const uint version
= *version_pos
- 0x30;
15375 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15381 oldoffice34
->version
= version
;
15383 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15384 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15385 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15386 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15388 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15389 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15390 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15391 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15393 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15394 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15395 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15396 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15397 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15399 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15400 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15401 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15402 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15403 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15409 salt
->salt_len
= 16;
15411 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15412 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15413 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15414 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15416 // this is a workaround as office produces multiple documents with the same salt
15418 salt
->salt_len
+= 32;
15420 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15421 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15422 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15423 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15424 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15425 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15426 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15427 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15433 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15434 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15435 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15436 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15438 return (PARSER_OK
);
15441 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15443 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15445 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15448 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15450 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15452 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15454 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15456 salt_t
*salt
= hash_buf
->salt
;
15458 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15464 char *version_pos
= input_buf
+ 11;
15466 char *osalt_pos
= strchr (version_pos
, '*');
15468 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15470 uint32_t version_len
= osalt_pos
- version_pos
;
15472 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15476 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15478 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15480 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15482 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15484 encryptedVerifier_pos
++;
15486 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15488 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15490 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15492 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15494 encryptedVerifierHash_pos
++;
15496 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15498 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15500 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15502 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15506 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15508 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15510 const uint version
= *version_pos
- 0x30;
15512 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15518 oldoffice34
->version
= version
;
15520 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15521 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15522 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15523 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15525 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15526 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15527 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15528 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15530 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15531 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15532 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15533 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15534 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15536 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15537 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15538 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15539 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15540 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15542 oldoffice34
->rc4key
[1] = 0;
15543 oldoffice34
->rc4key
[0] = 0;
15545 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15546 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15547 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15548 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15549 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15550 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15551 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15552 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15553 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15554 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15556 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15557 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15563 salt
->salt_len
= 16;
15565 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15566 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15567 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15568 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15570 // this is a workaround as office produces multiple documents with the same salt
15572 salt
->salt_len
+= 32;
15574 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15575 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15576 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15577 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15578 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15579 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15580 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15581 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15587 digest
[0] = oldoffice34
->rc4key
[0];
15588 digest
[1] = oldoffice34
->rc4key
[1];
15592 return (PARSER_OK
);
15595 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15597 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15599 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15601 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15602 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15603 digest
[2] = hex_to_uint (&input_buf
[16]);
15604 digest
[3] = hex_to_uint (&input_buf
[24]);
15606 digest
[0] = byte_swap_32 (digest
[0]);
15607 digest
[1] = byte_swap_32 (digest
[1]);
15608 digest
[2] = byte_swap_32 (digest
[2]);
15609 digest
[3] = byte_swap_32 (digest
[3]);
15611 return (PARSER_OK
);
15614 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15616 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15618 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15620 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15622 salt_t
*salt
= hash_buf
->salt
;
15624 char *signature_pos
= input_buf
;
15626 char *salt_pos
= strchr (signature_pos
, '$');
15628 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15630 uint32_t signature_len
= salt_pos
- signature_pos
;
15632 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15636 char *hash_pos
= strchr (salt_pos
, '$');
15638 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15640 uint32_t salt_len
= hash_pos
- salt_pos
;
15642 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15646 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15648 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15650 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15651 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15652 digest
[2] = hex_to_uint (&hash_pos
[16]);
15653 digest
[3] = hex_to_uint (&hash_pos
[24]);
15654 digest
[4] = hex_to_uint (&hash_pos
[32]);
15656 digest
[0] -= SHA1M_A
;
15657 digest
[1] -= SHA1M_B
;
15658 digest
[2] -= SHA1M_C
;
15659 digest
[3] -= SHA1M_D
;
15660 digest
[4] -= SHA1M_E
;
15662 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15664 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15666 salt
->salt_len
= salt_len
;
15668 return (PARSER_OK
);
15671 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15673 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15675 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15677 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15679 salt_t
*salt
= hash_buf
->salt
;
15681 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15687 char *iter_pos
= input_buf
+ 14;
15689 const int iter
= atoi (iter_pos
);
15691 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15693 salt
->salt_iter
= iter
- 1;
15695 char *salt_pos
= strchr (iter_pos
, '$');
15697 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15701 char *hash_pos
= strchr (salt_pos
, '$');
15703 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15705 const uint salt_len
= hash_pos
- salt_pos
;
15709 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15711 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15713 salt
->salt_len
= salt_len
;
15715 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15716 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15718 // add some stuff to normal salt to make sorted happy
15720 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15721 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15722 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15723 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15724 salt
->salt_buf
[4] = salt
->salt_iter
;
15726 // base64 decode hash
15730 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15732 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15734 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15736 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15738 memcpy (digest
, tmp_buf
, 32);
15740 digest
[0] = byte_swap_32 (digest
[0]);
15741 digest
[1] = byte_swap_32 (digest
[1]);
15742 digest
[2] = byte_swap_32 (digest
[2]);
15743 digest
[3] = byte_swap_32 (digest
[3]);
15744 digest
[4] = byte_swap_32 (digest
[4]);
15745 digest
[5] = byte_swap_32 (digest
[5]);
15746 digest
[6] = byte_swap_32 (digest
[6]);
15747 digest
[7] = byte_swap_32 (digest
[7]);
15749 return (PARSER_OK
);
15752 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15754 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15756 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15758 salt_t
*salt
= hash_buf
->salt
;
15760 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15761 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15765 digest
[0] = byte_swap_32 (digest
[0]);
15766 digest
[1] = byte_swap_32 (digest
[1]);
15768 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15769 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15770 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15772 char iter_c
= input_buf
[17];
15773 char iter_d
= input_buf
[19];
15775 // atm only defaults, let's see if there's more request
15776 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15777 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15779 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15781 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15782 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15783 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15784 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15786 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15787 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15788 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15789 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15791 salt
->salt_len
= 16;
15793 return (PARSER_OK
);
15796 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15798 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15800 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15802 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15804 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15806 salt_t
*salt
= hash_buf
->salt
;
15808 char *salt_pos
= input_buf
+ 10;
15810 char *hash_pos
= strchr (salt_pos
, '$');
15812 uint salt_len
= hash_pos
- salt_pos
;
15814 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15818 uint hash_len
= input_len
- 10 - salt_len
- 1;
15820 // base64 decode salt
15824 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15826 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15828 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15830 tmp_buf
[salt_len
] = 0x80;
15832 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15834 salt
->salt_len
= salt_len
;
15836 // base64 decode salt
15838 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15840 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15842 uint user_len
= hash_len
- 32;
15844 char *tmp_hash
= tmp_buf
+ user_len
;
15846 user_len
--; // skip the trailing space
15848 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15849 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15850 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15851 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15853 digest
[0] = byte_swap_32 (digest
[0]);
15854 digest
[1] = byte_swap_32 (digest
[1]);
15855 digest
[2] = byte_swap_32 (digest
[2]);
15856 digest
[3] = byte_swap_32 (digest
[3]);
15858 // store username for host only (output hash if cracked)
15860 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15861 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15863 return (PARSER_OK
);
15866 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15868 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15870 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15872 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15874 salt_t
*salt
= hash_buf
->salt
;
15876 char *iter_pos
= input_buf
+ 10;
15878 uint32_t iter
= atoi (iter_pos
);
15882 return (PARSER_SALT_ITERATION
);
15885 iter
--; // first iteration is special
15887 salt
->salt_iter
= iter
;
15889 char *base64_pos
= strchr (iter_pos
, '}');
15891 if (base64_pos
== NULL
)
15893 return (PARSER_SIGNATURE_UNMATCHED
);
15898 // base64 decode salt
15900 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15904 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15906 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15908 if (decoded_len
< 24)
15910 return (PARSER_SALT_LENGTH
);
15915 uint salt_len
= decoded_len
- 20;
15917 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15918 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15920 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15922 salt
->salt_len
= salt_len
;
15926 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15928 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15929 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15930 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15931 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15932 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15934 return (PARSER_OK
);
15937 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15939 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15941 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15943 salt_t
*salt
= hash_buf
->salt
;
15945 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15946 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15947 digest
[2] = hex_to_uint (&input_buf
[16]);
15948 digest
[3] = hex_to_uint (&input_buf
[24]);
15949 digest
[4] = hex_to_uint (&input_buf
[32]);
15951 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15953 uint salt_len
= input_len
- 40 - 1;
15955 char *salt_buf
= input_buf
+ 40 + 1;
15957 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15959 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15961 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15963 salt
->salt_len
= salt_len
;
15965 return (PARSER_OK
);
15968 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15970 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15972 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15974 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15976 salt_t
*salt
= hash_buf
->salt
;
15978 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15984 char *V_pos
= input_buf
+ 5;
15986 char *R_pos
= strchr (V_pos
, '*');
15988 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15990 uint32_t V_len
= R_pos
- V_pos
;
15994 char *bits_pos
= strchr (R_pos
, '*');
15996 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15998 uint32_t R_len
= bits_pos
- R_pos
;
16002 char *P_pos
= strchr (bits_pos
, '*');
16004 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16006 uint32_t bits_len
= P_pos
- bits_pos
;
16010 char *enc_md_pos
= strchr (P_pos
, '*');
16012 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16014 uint32_t P_len
= enc_md_pos
- P_pos
;
16018 char *id_len_pos
= strchr (enc_md_pos
, '*');
16020 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16022 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16026 char *id_buf_pos
= strchr (id_len_pos
, '*');
16028 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16030 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16034 char *u_len_pos
= strchr (id_buf_pos
, '*');
16036 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16038 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16040 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16044 char *u_buf_pos
= strchr (u_len_pos
, '*');
16046 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16048 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16052 char *o_len_pos
= strchr (u_buf_pos
, '*');
16054 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16056 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16058 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16062 char *o_buf_pos
= strchr (o_len_pos
, '*');
16064 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16066 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16070 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;
16072 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16076 const int V
= atoi (V_pos
);
16077 const int R
= atoi (R_pos
);
16078 const int P
= atoi (P_pos
);
16080 if (V
!= 1) return (PARSER_SALT_VALUE
);
16081 if (R
!= 2) return (PARSER_SALT_VALUE
);
16083 const int enc_md
= atoi (enc_md_pos
);
16085 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16087 const int id_len
= atoi (id_len_pos
);
16088 const int u_len
= atoi (u_len_pos
);
16089 const int o_len
= atoi (o_len_pos
);
16091 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16092 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16093 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16095 const int bits
= atoi (bits_pos
);
16097 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16099 // copy data to esalt
16105 pdf
->enc_md
= enc_md
;
16107 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16108 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16109 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16110 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16111 pdf
->id_len
= id_len
;
16113 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16114 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16115 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16116 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16117 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16118 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16119 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16120 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16121 pdf
->u_len
= u_len
;
16123 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16124 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16125 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16126 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16127 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16128 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16129 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16130 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16131 pdf
->o_len
= o_len
;
16133 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16134 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16135 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16136 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16138 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16139 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16140 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16141 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16142 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16143 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16144 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16145 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16147 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16148 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16149 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16150 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16151 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16152 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16153 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16154 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16156 // we use ID for salt, maybe needs to change, we will see...
16158 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16159 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16160 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16161 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16162 salt
->salt_len
= pdf
->id_len
;
16164 digest
[0] = pdf
->u_buf
[0];
16165 digest
[1] = pdf
->u_buf
[1];
16166 digest
[2] = pdf
->u_buf
[2];
16167 digest
[3] = pdf
->u_buf
[3];
16169 return (PARSER_OK
);
16172 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16174 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16177 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16179 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16181 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16183 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16185 salt_t
*salt
= hash_buf
->salt
;
16187 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16193 char *V_pos
= input_buf
+ 5;
16195 char *R_pos
= strchr (V_pos
, '*');
16197 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16199 uint32_t V_len
= R_pos
- V_pos
;
16203 char *bits_pos
= strchr (R_pos
, '*');
16205 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16207 uint32_t R_len
= bits_pos
- R_pos
;
16211 char *P_pos
= strchr (bits_pos
, '*');
16213 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16215 uint32_t bits_len
= P_pos
- bits_pos
;
16219 char *enc_md_pos
= strchr (P_pos
, '*');
16221 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16223 uint32_t P_len
= enc_md_pos
- P_pos
;
16227 char *id_len_pos
= strchr (enc_md_pos
, '*');
16229 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16231 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16235 char *id_buf_pos
= strchr (id_len_pos
, '*');
16237 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16239 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16243 char *u_len_pos
= strchr (id_buf_pos
, '*');
16245 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16247 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16249 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16253 char *u_buf_pos
= strchr (u_len_pos
, '*');
16255 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16257 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16261 char *o_len_pos
= strchr (u_buf_pos
, '*');
16263 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16265 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16267 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16271 char *o_buf_pos
= strchr (o_len_pos
, '*');
16273 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16275 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16279 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16281 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16283 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16285 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16289 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;
16291 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16295 const int V
= atoi (V_pos
);
16296 const int R
= atoi (R_pos
);
16297 const int P
= atoi (P_pos
);
16299 if (V
!= 1) return (PARSER_SALT_VALUE
);
16300 if (R
!= 2) return (PARSER_SALT_VALUE
);
16302 const int enc_md
= atoi (enc_md_pos
);
16304 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16306 const int id_len
= atoi (id_len_pos
);
16307 const int u_len
= atoi (u_len_pos
);
16308 const int o_len
= atoi (o_len_pos
);
16310 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16311 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16312 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16314 const int bits
= atoi (bits_pos
);
16316 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16318 // copy data to esalt
16324 pdf
->enc_md
= enc_md
;
16326 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16327 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16328 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16329 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16330 pdf
->id_len
= id_len
;
16332 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16333 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16334 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16335 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16336 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16337 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16338 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16339 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16340 pdf
->u_len
= u_len
;
16342 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16343 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16344 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16345 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16346 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16347 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16348 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16349 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16350 pdf
->o_len
= o_len
;
16352 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16353 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16354 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16355 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16357 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16358 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16359 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16360 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16361 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16362 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16363 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16364 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16366 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16367 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16368 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16369 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16370 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16371 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16372 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16373 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16375 pdf
->rc4key
[1] = 0;
16376 pdf
->rc4key
[0] = 0;
16378 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16379 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16380 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16381 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16382 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16383 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16384 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16385 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16386 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16387 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16389 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16390 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16392 // we use ID for salt, maybe needs to change, we will see...
16394 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16395 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16396 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16397 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16398 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16399 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16400 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16401 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16402 salt
->salt_len
= pdf
->id_len
+ 16;
16404 digest
[0] = pdf
->rc4key
[0];
16405 digest
[1] = pdf
->rc4key
[1];
16409 return (PARSER_OK
);
16412 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16414 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16416 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16418 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16420 salt_t
*salt
= hash_buf
->salt
;
16422 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16428 char *V_pos
= input_buf
+ 5;
16430 char *R_pos
= strchr (V_pos
, '*');
16432 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16434 uint32_t V_len
= R_pos
- V_pos
;
16438 char *bits_pos
= strchr (R_pos
, '*');
16440 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16442 uint32_t R_len
= bits_pos
- R_pos
;
16446 char *P_pos
= strchr (bits_pos
, '*');
16448 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16450 uint32_t bits_len
= P_pos
- bits_pos
;
16454 char *enc_md_pos
= strchr (P_pos
, '*');
16456 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16458 uint32_t P_len
= enc_md_pos
- P_pos
;
16462 char *id_len_pos
= strchr (enc_md_pos
, '*');
16464 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16466 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16470 char *id_buf_pos
= strchr (id_len_pos
, '*');
16472 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16474 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16478 char *u_len_pos
= strchr (id_buf_pos
, '*');
16480 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16482 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16484 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16488 char *u_buf_pos
= strchr (u_len_pos
, '*');
16490 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16492 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16496 char *o_len_pos
= strchr (u_buf_pos
, '*');
16498 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16500 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16502 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16506 char *o_buf_pos
= strchr (o_len_pos
, '*');
16508 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16510 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16514 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;
16516 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16520 const int V
= atoi (V_pos
);
16521 const int R
= atoi (R_pos
);
16522 const int P
= atoi (P_pos
);
16526 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16527 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16529 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16531 const int id_len
= atoi (id_len_pos
);
16532 const int u_len
= atoi (u_len_pos
);
16533 const int o_len
= atoi (o_len_pos
);
16535 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16537 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16538 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16540 const int bits
= atoi (bits_pos
);
16542 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16548 enc_md
= atoi (enc_md_pos
);
16551 // copy data to esalt
16557 pdf
->enc_md
= enc_md
;
16559 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16560 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16561 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16562 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16566 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16567 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16568 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16569 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16572 pdf
->id_len
= id_len
;
16574 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16575 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16576 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16577 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16578 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16579 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16580 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16581 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16582 pdf
->u_len
= u_len
;
16584 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16585 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16586 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16587 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16588 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16589 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16590 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16591 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16592 pdf
->o_len
= o_len
;
16594 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16595 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16596 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16597 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16601 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16602 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16603 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16604 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16607 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16608 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16609 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16610 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16611 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16612 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16613 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16614 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16616 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16617 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16618 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16619 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16620 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16621 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16622 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16623 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16625 // precompute rc4 data for later use
16641 uint salt_pc_block
[32];
16643 char *salt_pc_ptr
= (char *) salt_pc_block
;
16645 memcpy (salt_pc_ptr
, padding
, 32);
16646 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16648 uint salt_pc_digest
[4];
16650 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16652 pdf
->rc4data
[0] = salt_pc_digest
[0];
16653 pdf
->rc4data
[1] = salt_pc_digest
[1];
16655 // we use ID for salt, maybe needs to change, we will see...
16657 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16658 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16659 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16660 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16661 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16662 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16663 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16664 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16665 salt
->salt_len
= pdf
->id_len
+ 16;
16667 salt
->salt_iter
= ROUNDS_PDF14
;
16669 digest
[0] = pdf
->u_buf
[0];
16670 digest
[1] = pdf
->u_buf
[1];
16674 return (PARSER_OK
);
16677 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16679 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16681 if (ret
!= PARSER_OK
)
16686 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16688 salt_t
*salt
= hash_buf
->salt
;
16690 digest
[0] -= SHA256M_A
;
16691 digest
[1] -= SHA256M_B
;
16692 digest
[2] -= SHA256M_C
;
16693 digest
[3] -= SHA256M_D
;
16694 digest
[4] -= SHA256M_E
;
16695 digest
[5] -= SHA256M_F
;
16696 digest
[6] -= SHA256M_G
;
16697 digest
[7] -= SHA256M_H
;
16699 salt
->salt_buf
[2] = 0x80;
16701 return (PARSER_OK
);
16704 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16706 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16708 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16710 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16712 salt_t
*salt
= hash_buf
->salt
;
16714 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16720 char *V_pos
= input_buf
+ 5;
16722 char *R_pos
= strchr (V_pos
, '*');
16724 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16726 uint32_t V_len
= R_pos
- V_pos
;
16730 char *bits_pos
= strchr (R_pos
, '*');
16732 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16734 uint32_t R_len
= bits_pos
- R_pos
;
16738 char *P_pos
= strchr (bits_pos
, '*');
16740 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16742 uint32_t bits_len
= P_pos
- bits_pos
;
16746 char *enc_md_pos
= strchr (P_pos
, '*');
16748 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16750 uint32_t P_len
= enc_md_pos
- P_pos
;
16754 char *id_len_pos
= strchr (enc_md_pos
, '*');
16756 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16758 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16762 char *id_buf_pos
= strchr (id_len_pos
, '*');
16764 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16766 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16770 char *u_len_pos
= strchr (id_buf_pos
, '*');
16772 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16774 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16778 char *u_buf_pos
= strchr (u_len_pos
, '*');
16780 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16782 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16786 char *o_len_pos
= strchr (u_buf_pos
, '*');
16788 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16790 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16794 char *o_buf_pos
= strchr (o_len_pos
, '*');
16796 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16798 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16802 char *last
= strchr (o_buf_pos
, '*');
16804 if (last
== NULL
) last
= input_buf
+ input_len
;
16806 uint32_t o_buf_len
= last
- o_buf_pos
;
16810 const int V
= atoi (V_pos
);
16811 const int R
= atoi (R_pos
);
16815 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16816 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16818 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16820 const int bits
= atoi (bits_pos
);
16822 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16824 int enc_md
= atoi (enc_md_pos
);
16826 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16828 const uint id_len
= atoi (id_len_pos
);
16829 const uint u_len
= atoi (u_len_pos
);
16830 const uint o_len
= atoi (o_len_pos
);
16832 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16833 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16834 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16835 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16836 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16837 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16838 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16839 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16841 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16842 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16843 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16845 // copy data to esalt
16847 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16849 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16851 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16854 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16855 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16857 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16858 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16860 salt
->salt_len
= 8;
16861 salt
->salt_iter
= ROUNDS_PDF17L8
;
16863 digest
[0] = pdf
->u_buf
[0];
16864 digest
[1] = pdf
->u_buf
[1];
16865 digest
[2] = pdf
->u_buf
[2];
16866 digest
[3] = pdf
->u_buf
[3];
16867 digest
[4] = pdf
->u_buf
[4];
16868 digest
[5] = pdf
->u_buf
[5];
16869 digest
[6] = pdf
->u_buf
[6];
16870 digest
[7] = pdf
->u_buf
[7];
16872 return (PARSER_OK
);
16875 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16877 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16879 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16881 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16883 salt_t
*salt
= hash_buf
->salt
;
16885 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16893 char *iter_pos
= input_buf
+ 7;
16895 uint32_t iter
= atoi (iter_pos
);
16897 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16898 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16900 // first is *raw* salt
16902 char *salt_pos
= strchr (iter_pos
, ':');
16904 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16908 char *hash_pos
= strchr (salt_pos
, ':');
16910 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16912 uint32_t salt_len
= hash_pos
- salt_pos
;
16914 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16918 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16920 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16924 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16926 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16928 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16930 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16931 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16933 salt
->salt_len
= salt_len
;
16934 salt
->salt_iter
= iter
- 1;
16940 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16942 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16944 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16946 memcpy (digest
, tmp_buf
, 16);
16948 digest
[0] = byte_swap_32 (digest
[0]);
16949 digest
[1] = byte_swap_32 (digest
[1]);
16950 digest
[2] = byte_swap_32 (digest
[2]);
16951 digest
[3] = byte_swap_32 (digest
[3]);
16953 // add some stuff to normal salt to make sorted happy
16955 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16956 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16957 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16958 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16959 salt
->salt_buf
[4] = salt
->salt_iter
;
16961 return (PARSER_OK
);
16964 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16966 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16968 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16970 salt_t
*salt
= hash_buf
->salt
;
16972 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16973 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16974 digest
[2] = hex_to_uint (&input_buf
[16]);
16975 digest
[3] = hex_to_uint (&input_buf
[24]);
16977 digest
[0] = byte_swap_32 (digest
[0]);
16978 digest
[1] = byte_swap_32 (digest
[1]);
16979 digest
[2] = byte_swap_32 (digest
[2]);
16980 digest
[3] = byte_swap_32 (digest
[3]);
16982 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16984 uint salt_len
= input_len
- 32 - 1;
16986 char *salt_buf
= input_buf
+ 32 + 1;
16988 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16990 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16992 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16994 salt
->salt_len
= salt_len
;
16996 return (PARSER_OK
);
16999 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17001 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17003 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17005 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17007 salt_t
*salt
= hash_buf
->salt
;
17009 char *user_pos
= input_buf
+ 10;
17011 char *salt_pos
= strchr (user_pos
, '*');
17013 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17017 char *hash_pos
= strchr (salt_pos
, '*');
17021 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17023 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17025 uint user_len
= salt_pos
- user_pos
- 1;
17027 uint salt_len
= hash_pos
- salt_pos
- 1;
17029 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17035 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17036 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17037 digest
[2] = hex_to_uint (&hash_pos
[16]);
17038 digest
[3] = hex_to_uint (&hash_pos
[24]);
17040 digest
[0] = byte_swap_32 (digest
[0]);
17041 digest
[1] = byte_swap_32 (digest
[1]);
17042 digest
[2] = byte_swap_32 (digest
[2]);
17043 digest
[3] = byte_swap_32 (digest
[3]);
17045 digest
[0] -= MD5M_A
;
17046 digest
[1] -= MD5M_B
;
17047 digest
[2] -= MD5M_C
;
17048 digest
[3] -= MD5M_D
;
17054 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17056 // first 4 bytes are the "challenge"
17058 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17059 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17060 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17061 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17063 // append the user name
17065 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17067 salt
->salt_len
= 4 + user_len
;
17069 return (PARSER_OK
);
17072 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17074 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17076 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17078 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17080 salt_t
*salt
= hash_buf
->salt
;
17082 char *salt_pos
= input_buf
+ 9;
17084 char *hash_pos
= strchr (salt_pos
, '*');
17086 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17090 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17092 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17094 uint salt_len
= hash_pos
- salt_pos
- 1;
17096 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17102 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17103 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17104 digest
[2] = hex_to_uint (&hash_pos
[16]);
17105 digest
[3] = hex_to_uint (&hash_pos
[24]);
17106 digest
[4] = hex_to_uint (&hash_pos
[32]);
17112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17116 salt
->salt_len
= salt_len
;
17118 return (PARSER_OK
);
17121 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17123 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17125 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17127 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17129 salt_t
*salt
= hash_buf
->salt
;
17131 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17137 char *cry_master_len_pos
= input_buf
+ 9;
17139 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17141 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17143 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17145 cry_master_buf_pos
++;
17147 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17149 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17151 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17153 cry_salt_len_pos
++;
17155 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17157 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17159 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17161 cry_salt_buf_pos
++;
17163 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17165 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17167 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17171 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17173 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17175 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17179 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17181 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17183 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17187 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17189 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17191 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17193 public_key_len_pos
++;
17195 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17197 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17199 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17201 public_key_buf_pos
++;
17203 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;
17205 const uint cry_master_len
= atoi (cry_master_len_pos
);
17206 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17207 const uint ckey_len
= atoi (ckey_len_pos
);
17208 const uint public_key_len
= atoi (public_key_len_pos
);
17210 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17211 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17212 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17213 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17215 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17217 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17219 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17222 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17224 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17226 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17229 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17231 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17233 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17236 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17237 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17238 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17241 * store digest (should be unique enought, hopefully)
17244 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17245 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17246 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17247 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17253 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17255 const uint cry_rounds
= atoi (cry_rounds_pos
);
17257 salt
->salt_iter
= cry_rounds
- 1;
17259 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17261 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17263 salt
->salt_len
= salt_len
;
17265 return (PARSER_OK
);
17268 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17270 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17272 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17274 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17276 salt_t
*salt
= hash_buf
->salt
;
17278 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17280 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17282 char temp_input_buf
[input_len
+ 1];
17284 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17285 memcpy (temp_input_buf
, input_buf
, input_len
);
17289 char *URI_server_pos
= temp_input_buf
+ 6;
17291 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17293 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17295 URI_client_pos
[0] = 0;
17298 uint URI_server_len
= strlen (URI_server_pos
);
17300 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17304 char *user_pos
= strchr (URI_client_pos
, '*');
17306 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 uint URI_client_len
= strlen (URI_client_pos
);
17313 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17317 char *realm_pos
= strchr (user_pos
, '*');
17319 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17324 uint user_len
= strlen (user_pos
);
17326 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17330 char *method_pos
= strchr (realm_pos
, '*');
17332 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17337 uint realm_len
= strlen (realm_pos
);
17339 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17343 char *URI_prefix_pos
= strchr (method_pos
, '*');
17345 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17347 URI_prefix_pos
[0] = 0;
17350 uint method_len
= strlen (method_pos
);
17352 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17356 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17358 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17360 URI_resource_pos
[0] = 0;
17361 URI_resource_pos
++;
17363 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17365 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17369 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17371 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17373 URI_suffix_pos
[0] = 0;
17376 uint URI_resource_len
= strlen (URI_resource_pos
);
17378 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17379 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17383 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17385 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17390 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17392 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17396 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17398 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17400 nonce_client_pos
[0] = 0;
17401 nonce_client_pos
++;
17403 uint nonce_len
= strlen (nonce_pos
);
17405 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17406 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17410 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17412 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17414 nonce_count_pos
[0] = 0;
17417 uint nonce_client_len
= strlen (nonce_client_pos
);
17419 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17423 char *qop_pos
= strchr (nonce_count_pos
, '*');
17425 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17430 uint nonce_count_len
= strlen (nonce_count_pos
);
17432 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17436 char *directive_pos
= strchr (qop_pos
, '*');
17438 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17440 directive_pos
[0] = 0;
17443 uint qop_len
= strlen (qop_pos
);
17445 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17449 char *digest_pos
= strchr (directive_pos
, '*');
17451 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17456 uint directive_len
= strlen (directive_pos
);
17458 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17460 if (memcmp (directive_pos
, "MD5", 3))
17462 log_info ("ERROR: only the MD5 directive is currently supported\n");
17464 return (PARSER_SIP_AUTH_DIRECTIVE
);
17468 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17473 uint md5_max_len
= 4 * 64;
17475 uint md5_remaining_len
= md5_max_len
;
17477 uint tmp_md5_buf
[md5_max_len
/ 4];
17479 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17481 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17483 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17485 md5_len
+= method_len
+ 1;
17486 tmp_md5_ptr
+= method_len
+ 1;
17488 if (URI_prefix_len
> 0)
17490 md5_remaining_len
= md5_max_len
- md5_len
;
17492 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17494 md5_len
+= URI_prefix_len
+ 1;
17495 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17498 md5_remaining_len
= md5_max_len
- md5_len
;
17500 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17502 md5_len
+= URI_resource_len
;
17503 tmp_md5_ptr
+= URI_resource_len
;
17505 if (URI_suffix_len
> 0)
17507 md5_remaining_len
= md5_max_len
- md5_len
;
17509 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17511 md5_len
+= 1 + URI_suffix_len
;
17514 uint tmp_digest
[4];
17516 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17518 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17519 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17520 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17521 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17527 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17529 uint esalt_len
= 0;
17531 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17533 // there are 2 possibilities for the esalt:
17535 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17537 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17539 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17541 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17553 esalt_len
= 1 + nonce_len
+ 1 + 32;
17555 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17557 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17565 // add 0x80 to esalt
17567 esalt_buf_ptr
[esalt_len
] = 0x80;
17569 sip
->esalt_len
= esalt_len
;
17575 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17577 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17579 uint max_salt_len
= 119;
17581 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17583 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17585 sip
->salt_len
= salt_len
;
17588 * fake salt (for sorting)
17591 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17595 uint fake_salt_len
= salt_len
;
17597 if (fake_salt_len
> max_salt_len
)
17599 fake_salt_len
= max_salt_len
;
17602 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17604 salt
->salt_len
= fake_salt_len
;
17610 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17611 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17612 digest
[2] = hex_to_uint (&digest_pos
[16]);
17613 digest
[3] = hex_to_uint (&digest_pos
[24]);
17615 digest
[0] = byte_swap_32 (digest
[0]);
17616 digest
[1] = byte_swap_32 (digest
[1]);
17617 digest
[2] = byte_swap_32 (digest
[2]);
17618 digest
[3] = byte_swap_32 (digest
[3]);
17620 return (PARSER_OK
);
17623 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17625 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17627 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17629 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17631 salt_t
*salt
= hash_buf
->salt
;
17635 char *digest_pos
= input_buf
;
17637 digest
[0] = hex_to_uint (&digest_pos
[0]);
17644 char *salt_buf
= input_buf
+ 8 + 1;
17648 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17650 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17652 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17654 salt
->salt_len
= salt_len
;
17656 return (PARSER_OK
);
17659 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17661 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17663 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17665 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17667 salt_t
*salt
= hash_buf
->salt
;
17669 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17675 char *p_buf_pos
= input_buf
+ 4;
17677 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17679 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17681 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17683 NumCyclesPower_pos
++;
17685 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17687 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17689 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17693 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17695 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17697 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17701 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17703 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17705 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17709 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17711 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17713 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17717 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17719 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17721 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17725 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17727 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17729 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17733 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17735 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17737 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17741 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17743 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17745 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17749 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;
17751 const uint iter
= atoi (NumCyclesPower_pos
);
17752 const uint crc
= atoi (crc_buf_pos
);
17753 const uint p_buf
= atoi (p_buf_pos
);
17754 const uint salt_len
= atoi (salt_len_pos
);
17755 const uint iv_len
= atoi (iv_len_pos
);
17756 const uint unpack_size
= atoi (unpack_size_pos
);
17757 const uint data_len
= atoi (data_len_pos
);
17763 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17764 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17766 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17768 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17770 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17776 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17777 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17778 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17779 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17781 seven_zip
->iv_len
= iv_len
;
17783 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17785 seven_zip
->salt_len
= 0;
17787 seven_zip
->crc
= crc
;
17789 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17791 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17793 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17796 seven_zip
->data_len
= data_len
;
17798 seven_zip
->unpack_size
= unpack_size
;
17802 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17803 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17804 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17805 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17807 salt
->salt_len
= 16;
17809 salt
->salt_sign
[0] = iter
;
17811 salt
->salt_iter
= 1 << iter
;
17822 return (PARSER_OK
);
17825 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17827 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17829 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17831 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17832 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17833 digest
[2] = hex_to_uint (&input_buf
[16]);
17834 digest
[3] = hex_to_uint (&input_buf
[24]);
17835 digest
[4] = hex_to_uint (&input_buf
[32]);
17836 digest
[5] = hex_to_uint (&input_buf
[40]);
17837 digest
[6] = hex_to_uint (&input_buf
[48]);
17838 digest
[7] = hex_to_uint (&input_buf
[56]);
17840 digest
[0] = byte_swap_32 (digest
[0]);
17841 digest
[1] = byte_swap_32 (digest
[1]);
17842 digest
[2] = byte_swap_32 (digest
[2]);
17843 digest
[3] = byte_swap_32 (digest
[3]);
17844 digest
[4] = byte_swap_32 (digest
[4]);
17845 digest
[5] = byte_swap_32 (digest
[5]);
17846 digest
[6] = byte_swap_32 (digest
[6]);
17847 digest
[7] = byte_swap_32 (digest
[7]);
17849 return (PARSER_OK
);
17852 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17854 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17856 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17858 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17859 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17860 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17861 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17862 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17863 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17864 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17865 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17866 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17867 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17868 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17869 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17870 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17871 digest
[13] = hex_to_uint (&input_buf
[104]);
17872 digest
[14] = hex_to_uint (&input_buf
[112]);
17873 digest
[15] = hex_to_uint (&input_buf
[120]);
17875 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17876 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17877 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17878 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17879 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17880 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17881 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17882 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17883 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17884 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17885 digest
[10] = byte_swap_32 (digest
[10]);
17886 digest
[11] = byte_swap_32 (digest
[11]);
17887 digest
[12] = byte_swap_32 (digest
[12]);
17888 digest
[13] = byte_swap_32 (digest
[13]);
17889 digest
[14] = byte_swap_32 (digest
[14]);
17890 digest
[15] = byte_swap_32 (digest
[15]);
17892 return (PARSER_OK
);
17895 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17897 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17899 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17901 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17903 salt_t
*salt
= hash_buf
->salt
;
17905 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17913 char *iter_pos
= input_buf
+ 4;
17915 uint32_t iter
= atoi (iter_pos
);
17917 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17918 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17920 // first is *raw* salt
17922 char *salt_pos
= strchr (iter_pos
, ':');
17924 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17928 char *hash_pos
= strchr (salt_pos
, ':');
17930 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17932 uint32_t salt_len
= hash_pos
- salt_pos
;
17934 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17938 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17940 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17944 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17946 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17948 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17950 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17951 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17953 salt
->salt_len
= salt_len
;
17954 salt
->salt_iter
= iter
- 1;
17960 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17962 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17964 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17966 memcpy (digest
, tmp_buf
, 16);
17968 // add some stuff to normal salt to make sorted happy
17970 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17971 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17972 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17973 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17974 salt
->salt_buf
[4] = salt
->salt_iter
;
17976 return (PARSER_OK
);
17979 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17981 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17983 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17985 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17987 salt_t
*salt
= hash_buf
->salt
;
17989 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
17997 char *iter_pos
= input_buf
+ 5;
17999 uint32_t iter
= atoi (iter_pos
);
18001 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18002 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18004 // first is *raw* salt
18006 char *salt_pos
= strchr (iter_pos
, ':');
18008 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18012 char *hash_pos
= strchr (salt_pos
, ':');
18014 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18016 uint32_t salt_len
= hash_pos
- salt_pos
;
18018 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18022 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18024 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18028 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18030 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18032 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18034 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18035 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18037 salt
->salt_len
= salt_len
;
18038 salt
->salt_iter
= iter
- 1;
18044 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18046 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18048 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18050 memcpy (digest
, tmp_buf
, 16);
18052 digest
[0] = byte_swap_32 (digest
[0]);
18053 digest
[1] = byte_swap_32 (digest
[1]);
18054 digest
[2] = byte_swap_32 (digest
[2]);
18055 digest
[3] = byte_swap_32 (digest
[3]);
18057 // add some stuff to normal salt to make sorted happy
18059 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18060 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18061 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18062 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18063 salt
->salt_buf
[4] = salt
->salt_iter
;
18065 return (PARSER_OK
);
18068 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18070 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18072 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18074 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18076 salt_t
*salt
= hash_buf
->salt
;
18078 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18086 char *iter_pos
= input_buf
+ 7;
18088 uint32_t iter
= atoi (iter_pos
);
18090 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18091 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18093 // first is *raw* salt
18095 char *salt_pos
= strchr (iter_pos
, ':');
18097 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18101 char *hash_pos
= strchr (salt_pos
, ':');
18103 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18105 uint32_t salt_len
= hash_pos
- salt_pos
;
18107 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18111 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18113 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18117 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18119 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18121 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18123 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18124 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18126 salt
->salt_len
= salt_len
;
18127 salt
->salt_iter
= iter
- 1;
18133 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18135 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18137 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18139 memcpy (digest
, tmp_buf
, 64);
18141 digest
[0] = byte_swap_64 (digest
[0]);
18142 digest
[1] = byte_swap_64 (digest
[1]);
18143 digest
[2] = byte_swap_64 (digest
[2]);
18144 digest
[3] = byte_swap_64 (digest
[3]);
18145 digest
[4] = byte_swap_64 (digest
[4]);
18146 digest
[5] = byte_swap_64 (digest
[5]);
18147 digest
[6] = byte_swap_64 (digest
[6]);
18148 digest
[7] = byte_swap_64 (digest
[7]);
18150 // add some stuff to normal salt to make sorted happy
18152 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18153 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18154 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18155 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18156 salt
->salt_buf
[4] = salt
->salt_iter
;
18158 return (PARSER_OK
);
18161 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18163 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18165 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18167 uint
*digest
= (uint
*) hash_buf
->digest
;
18169 salt_t
*salt
= hash_buf
->salt
;
18175 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18177 char *hash_pos
= strchr (salt_pos
, '$');
18179 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18181 uint32_t salt_len
= hash_pos
- salt_pos
;
18183 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18187 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18189 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18193 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18194 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18212 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18213 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18215 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18216 salt
->salt_len
= 8;
18218 return (PARSER_OK
);
18221 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18223 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18225 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18227 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18229 if (c19
& 3) return (PARSER_HASH_VALUE
);
18231 salt_t
*salt
= hash_buf
->salt
;
18233 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18237 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18238 | itoa64_to_int (input_buf
[2]) << 6
18239 | itoa64_to_int (input_buf
[3]) << 12
18240 | itoa64_to_int (input_buf
[4]) << 18;
18244 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18245 | itoa64_to_int (input_buf
[6]) << 6
18246 | itoa64_to_int (input_buf
[7]) << 12
18247 | itoa64_to_int (input_buf
[8]) << 18;
18249 salt
->salt_len
= 4;
18253 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18255 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18257 memcpy (digest
, tmp_buf
, 8);
18261 IP (digest
[0], digest
[1], tt
);
18263 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18264 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18268 return (PARSER_OK
);
18271 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18273 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18275 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18277 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18279 salt_t
*salt
= hash_buf
->salt
;
18285 char *type_pos
= input_buf
+ 6 + 1;
18287 char *salt_pos
= strchr (type_pos
, '*');
18289 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18291 uint32_t type_len
= salt_pos
- type_pos
;
18293 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18297 char *crypted_pos
= strchr (salt_pos
, '*');
18299 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18301 uint32_t salt_len
= crypted_pos
- salt_pos
;
18303 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18307 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18309 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18315 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18316 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18318 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18319 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18321 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18322 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18323 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18324 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18326 salt
->salt_len
= 24;
18327 salt
->salt_iter
= ROUNDS_RAR3
;
18329 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18330 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18332 digest
[0] = 0xc43d7b00;
18333 digest
[1] = 0x40070000;
18337 return (PARSER_OK
);
18340 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18342 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18344 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18346 salt_t
*salt
= hash_buf
->salt
;
18348 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18349 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18350 digest
[2] = hex_to_uint (&input_buf
[16]);
18351 digest
[3] = hex_to_uint (&input_buf
[24]);
18352 digest
[4] = hex_to_uint (&input_buf
[32]);
18353 digest
[5] = hex_to_uint (&input_buf
[40]);
18354 digest
[6] = hex_to_uint (&input_buf
[48]);
18355 digest
[7] = hex_to_uint (&input_buf
[56]);
18357 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18359 uint salt_len
= input_len
- 64 - 1;
18361 char *salt_buf
= input_buf
+ 64 + 1;
18363 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18365 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18367 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18369 salt
->salt_len
= salt_len
;
18372 * we can precompute the first sha256 transform
18377 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18378 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18379 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18380 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18381 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18382 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18383 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18384 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18385 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18386 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18387 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18388 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18389 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18390 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18391 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18392 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18396 pc256
[0] = SHA256M_A
;
18397 pc256
[1] = SHA256M_B
;
18398 pc256
[2] = SHA256M_C
;
18399 pc256
[3] = SHA256M_D
;
18400 pc256
[4] = SHA256M_E
;
18401 pc256
[5] = SHA256M_F
;
18402 pc256
[6] = SHA256M_G
;
18403 pc256
[7] = SHA256M_H
;
18405 sha256_64 (w
, pc256
);
18407 salt
->salt_buf_pc
[0] = pc256
[0];
18408 salt
->salt_buf_pc
[1] = pc256
[1];
18409 salt
->salt_buf_pc
[2] = pc256
[2];
18410 salt
->salt_buf_pc
[3] = pc256
[3];
18411 salt
->salt_buf_pc
[4] = pc256
[4];
18412 salt
->salt_buf_pc
[5] = pc256
[5];
18413 salt
->salt_buf_pc
[6] = pc256
[6];
18414 salt
->salt_buf_pc
[7] = pc256
[7];
18416 digest
[0] -= pc256
[0];
18417 digest
[1] -= pc256
[1];
18418 digest
[2] -= pc256
[2];
18419 digest
[3] -= pc256
[3];
18420 digest
[4] -= pc256
[4];
18421 digest
[5] -= pc256
[5];
18422 digest
[6] -= pc256
[6];
18423 digest
[7] -= pc256
[7];
18425 return (PARSER_OK
);
18428 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18430 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18432 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18434 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18436 salt_t
*salt
= hash_buf
->salt
;
18442 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18444 char *data_buf_pos
= strchr (data_len_pos
, '$');
18446 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18448 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18450 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18451 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18455 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18457 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18459 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18461 uint32_t data_len
= atoi (data_len_pos
);
18463 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18469 char *salt_pos
= data_buf_pos
;
18471 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18472 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18473 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18474 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18476 // this is actually the CT, which is also the hash later (if matched)
18478 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18479 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18480 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18481 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18483 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18485 salt
->salt_iter
= 10 - 1;
18491 digest
[0] = salt
->salt_buf
[4];
18492 digest
[1] = salt
->salt_buf
[5];
18493 digest
[2] = salt
->salt_buf
[6];
18494 digest
[3] = salt
->salt_buf
[7];
18496 return (PARSER_OK
);
18499 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18501 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18503 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18505 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18507 salt_t
*salt
= hash_buf
->salt
;
18513 char *salt_pos
= input_buf
+ 11 + 1;
18515 char *iter_pos
= strchr (salt_pos
, ',');
18517 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18519 uint32_t salt_len
= iter_pos
- salt_pos
;
18521 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18525 char *hash_pos
= strchr (iter_pos
, ',');
18527 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18529 uint32_t iter_len
= hash_pos
- iter_pos
;
18531 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18535 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18537 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18543 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18544 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18545 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18546 salt
->salt_buf
[3] = 0x00018000;
18548 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18549 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18550 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18551 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18553 salt
->salt_len
= salt_len
/ 2;
18555 salt
->salt_iter
= atoi (iter_pos
) - 1;
18561 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18562 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18563 digest
[2] = hex_to_uint (&hash_pos
[16]);
18564 digest
[3] = hex_to_uint (&hash_pos
[24]);
18565 digest
[4] = hex_to_uint (&hash_pos
[32]);
18566 digest
[5] = hex_to_uint (&hash_pos
[40]);
18567 digest
[6] = hex_to_uint (&hash_pos
[48]);
18568 digest
[7] = hex_to_uint (&hash_pos
[56]);
18570 return (PARSER_OK
);
18574 * parallel running threads
18579 BOOL WINAPI
sigHandler_default (DWORD sig
)
18583 case CTRL_CLOSE_EVENT
:
18586 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18587 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18588 * function otherwise it is to late (e.g. after returning from this function)
18593 SetConsoleCtrlHandler (NULL
, TRUE
);
18600 case CTRL_LOGOFF_EVENT
:
18601 case CTRL_SHUTDOWN_EVENT
:
18605 SetConsoleCtrlHandler (NULL
, TRUE
);
18613 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18617 case CTRL_CLOSE_EVENT
:
18621 SetConsoleCtrlHandler (NULL
, TRUE
);
18628 case CTRL_LOGOFF_EVENT
:
18629 case CTRL_SHUTDOWN_EVENT
:
18633 SetConsoleCtrlHandler (NULL
, TRUE
);
18641 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18643 if (callback
== NULL
)
18645 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18649 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18655 void sigHandler_default (int sig
)
18659 signal (sig
, NULL
);
18662 void sigHandler_benchmark (int sig
)
18666 signal (sig
, NULL
);
18669 void hc_signal (void (callback
) (int))
18671 if (callback
== NULL
) callback
= SIG_DFL
;
18673 signal (SIGINT
, callback
);
18674 signal (SIGTERM
, callback
);
18675 signal (SIGABRT
, callback
);
18680 void status_display ();
18682 void *thread_keypress (void *p
)
18684 int benchmark
= *((int *) p
);
18686 uint quiet
= data
.quiet
;
18690 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18692 int ch
= tty_getchar();
18694 if (ch
== -1) break;
18696 if (ch
== 0) continue;
18702 hc_thread_mutex_lock (mux_display
);
18717 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18718 if (quiet
== 0) fflush (stdout
);
18730 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18731 if (quiet
== 0) fflush (stdout
);
18743 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18744 if (quiet
== 0) fflush (stdout
);
18756 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18757 if (quiet
== 0) fflush (stdout
);
18765 if (benchmark
== 1) break;
18767 stop_at_checkpoint ();
18771 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18772 if (quiet
== 0) fflush (stdout
);
18780 if (benchmark
== 1)
18792 hc_thread_mutex_unlock (mux_display
);
18804 bool class_num (char c
)
18806 return ((c
>= '0') && (c
<= '9'));
18809 bool class_lower (char c
)
18811 return ((c
>= 'a') && (c
<= 'z'));
18814 bool class_upper (char c
)
18816 return ((c
>= 'A') && (c
<= 'Z'));
18819 bool class_alpha (char c
)
18821 return (class_lower (c
) || class_upper (c
));
18824 char conv_ctoi (char c
)
18830 else if (class_upper (c
))
18832 return c
- 'A' + (char) 10;
18835 return (char) (-1);
18838 char conv_itoc (char c
)
18846 return c
+ 'A' - (char) 10;
18849 return (char) (-1);
18856 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18857 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18858 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18859 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18860 #define MAX_GPU_RULES 255
18861 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18862 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18863 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18865 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18866 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18867 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18868 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18870 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18875 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18877 switch (rule_buf
[rule_pos
])
18883 case RULE_OP_MANGLE_NOOP
:
18884 SET_NAME (rule
, rule_buf
[rule_pos
]);
18887 case RULE_OP_MANGLE_LREST
:
18888 SET_NAME (rule
, rule_buf
[rule_pos
]);
18891 case RULE_OP_MANGLE_UREST
:
18892 SET_NAME (rule
, rule_buf
[rule_pos
]);
18895 case RULE_OP_MANGLE_LREST_UFIRST
:
18896 SET_NAME (rule
, rule_buf
[rule_pos
]);
18899 case RULE_OP_MANGLE_UREST_LFIRST
:
18900 SET_NAME (rule
, rule_buf
[rule_pos
]);
18903 case RULE_OP_MANGLE_TREST
:
18904 SET_NAME (rule
, rule_buf
[rule_pos
]);
18907 case RULE_OP_MANGLE_TOGGLE_AT
:
18908 SET_NAME (rule
, rule_buf
[rule_pos
]);
18909 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18912 case RULE_OP_MANGLE_REVERSE
:
18913 SET_NAME (rule
, rule_buf
[rule_pos
]);
18916 case RULE_OP_MANGLE_DUPEWORD
:
18917 SET_NAME (rule
, rule_buf
[rule_pos
]);
18920 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18921 SET_NAME (rule
, rule_buf
[rule_pos
]);
18922 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18925 case RULE_OP_MANGLE_REFLECT
:
18926 SET_NAME (rule
, rule_buf
[rule_pos
]);
18929 case RULE_OP_MANGLE_ROTATE_LEFT
:
18930 SET_NAME (rule
, rule_buf
[rule_pos
]);
18933 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18934 SET_NAME (rule
, rule_buf
[rule_pos
]);
18937 case RULE_OP_MANGLE_APPEND
:
18938 SET_NAME (rule
, rule_buf
[rule_pos
]);
18939 SET_P0 (rule
, rule_buf
[rule_pos
]);
18942 case RULE_OP_MANGLE_PREPEND
:
18943 SET_NAME (rule
, rule_buf
[rule_pos
]);
18944 SET_P0 (rule
, rule_buf
[rule_pos
]);
18947 case RULE_OP_MANGLE_DELETE_FIRST
:
18948 SET_NAME (rule
, rule_buf
[rule_pos
]);
18951 case RULE_OP_MANGLE_DELETE_LAST
:
18952 SET_NAME (rule
, rule_buf
[rule_pos
]);
18955 case RULE_OP_MANGLE_DELETE_AT
:
18956 SET_NAME (rule
, rule_buf
[rule_pos
]);
18957 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18960 case RULE_OP_MANGLE_EXTRACT
:
18961 SET_NAME (rule
, rule_buf
[rule_pos
]);
18962 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18963 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18966 case RULE_OP_MANGLE_OMIT
:
18967 SET_NAME (rule
, rule_buf
[rule_pos
]);
18968 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18969 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18972 case RULE_OP_MANGLE_INSERT
:
18973 SET_NAME (rule
, rule_buf
[rule_pos
]);
18974 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18975 SET_P1 (rule
, rule_buf
[rule_pos
]);
18978 case RULE_OP_MANGLE_OVERSTRIKE
:
18979 SET_NAME (rule
, rule_buf
[rule_pos
]);
18980 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18981 SET_P1 (rule
, rule_buf
[rule_pos
]);
18984 case RULE_OP_MANGLE_TRUNCATE_AT
:
18985 SET_NAME (rule
, rule_buf
[rule_pos
]);
18986 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18989 case RULE_OP_MANGLE_REPLACE
:
18990 SET_NAME (rule
, rule_buf
[rule_pos
]);
18991 SET_P0 (rule
, rule_buf
[rule_pos
]);
18992 SET_P1 (rule
, rule_buf
[rule_pos
]);
18995 case RULE_OP_MANGLE_PURGECHAR
:
18999 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19003 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19004 SET_NAME (rule
, rule_buf
[rule_pos
]);
19005 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19008 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19009 SET_NAME (rule
, rule_buf
[rule_pos
]);
19010 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19013 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19014 SET_NAME (rule
, rule_buf
[rule_pos
]);
19017 case RULE_OP_MANGLE_SWITCH_FIRST
:
19018 SET_NAME (rule
, rule_buf
[rule_pos
]);
19021 case RULE_OP_MANGLE_SWITCH_LAST
:
19022 SET_NAME (rule
, rule_buf
[rule_pos
]);
19025 case RULE_OP_MANGLE_SWITCH_AT
:
19026 SET_NAME (rule
, rule_buf
[rule_pos
]);
19027 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19028 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19031 case RULE_OP_MANGLE_CHR_SHIFTL
:
19032 SET_NAME (rule
, rule_buf
[rule_pos
]);
19033 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19036 case RULE_OP_MANGLE_CHR_SHIFTR
:
19037 SET_NAME (rule
, rule_buf
[rule_pos
]);
19038 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19041 case RULE_OP_MANGLE_CHR_INCR
:
19042 SET_NAME (rule
, rule_buf
[rule_pos
]);
19043 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19046 case RULE_OP_MANGLE_CHR_DECR
:
19047 SET_NAME (rule
, rule_buf
[rule_pos
]);
19048 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19051 case RULE_OP_MANGLE_REPLACE_NP1
:
19052 SET_NAME (rule
, rule_buf
[rule_pos
]);
19053 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19056 case RULE_OP_MANGLE_REPLACE_NM1
:
19057 SET_NAME (rule
, rule_buf
[rule_pos
]);
19058 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19061 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19062 SET_NAME (rule
, rule_buf
[rule_pos
]);
19063 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19066 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19067 SET_NAME (rule
, rule_buf
[rule_pos
]);
19068 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19071 case RULE_OP_MANGLE_TITLE
:
19072 SET_NAME (rule
, rule_buf
[rule_pos
]);
19081 if (rule_pos
< rule_len
) return (-1);
19086 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19090 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19094 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19098 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19102 case RULE_OP_MANGLE_NOOP
:
19103 rule_buf
[rule_pos
] = rule_cmd
;
19106 case RULE_OP_MANGLE_LREST
:
19107 rule_buf
[rule_pos
] = rule_cmd
;
19110 case RULE_OP_MANGLE_UREST
:
19111 rule_buf
[rule_pos
] = rule_cmd
;
19114 case RULE_OP_MANGLE_LREST_UFIRST
:
19115 rule_buf
[rule_pos
] = rule_cmd
;
19118 case RULE_OP_MANGLE_UREST_LFIRST
:
19119 rule_buf
[rule_pos
] = rule_cmd
;
19122 case RULE_OP_MANGLE_TREST
:
19123 rule_buf
[rule_pos
] = rule_cmd
;
19126 case RULE_OP_MANGLE_TOGGLE_AT
:
19127 rule_buf
[rule_pos
] = rule_cmd
;
19128 GET_P0_CONV (rule
);
19131 case RULE_OP_MANGLE_REVERSE
:
19132 rule_buf
[rule_pos
] = rule_cmd
;
19135 case RULE_OP_MANGLE_DUPEWORD
:
19136 rule_buf
[rule_pos
] = rule_cmd
;
19139 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19140 rule_buf
[rule_pos
] = rule_cmd
;
19141 GET_P0_CONV (rule
);
19144 case RULE_OP_MANGLE_REFLECT
:
19145 rule_buf
[rule_pos
] = rule_cmd
;
19148 case RULE_OP_MANGLE_ROTATE_LEFT
:
19149 rule_buf
[rule_pos
] = rule_cmd
;
19152 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19153 rule_buf
[rule_pos
] = rule_cmd
;
19156 case RULE_OP_MANGLE_APPEND
:
19157 rule_buf
[rule_pos
] = rule_cmd
;
19161 case RULE_OP_MANGLE_PREPEND
:
19162 rule_buf
[rule_pos
] = rule_cmd
;
19166 case RULE_OP_MANGLE_DELETE_FIRST
:
19167 rule_buf
[rule_pos
] = rule_cmd
;
19170 case RULE_OP_MANGLE_DELETE_LAST
:
19171 rule_buf
[rule_pos
] = rule_cmd
;
19174 case RULE_OP_MANGLE_DELETE_AT
:
19175 rule_buf
[rule_pos
] = rule_cmd
;
19176 GET_P0_CONV (rule
);
19179 case RULE_OP_MANGLE_EXTRACT
:
19180 rule_buf
[rule_pos
] = rule_cmd
;
19181 GET_P0_CONV (rule
);
19182 GET_P1_CONV (rule
);
19185 case RULE_OP_MANGLE_OMIT
:
19186 rule_buf
[rule_pos
] = rule_cmd
;
19187 GET_P0_CONV (rule
);
19188 GET_P1_CONV (rule
);
19191 case RULE_OP_MANGLE_INSERT
:
19192 rule_buf
[rule_pos
] = rule_cmd
;
19193 GET_P0_CONV (rule
);
19197 case RULE_OP_MANGLE_OVERSTRIKE
:
19198 rule_buf
[rule_pos
] = rule_cmd
;
19199 GET_P0_CONV (rule
);
19203 case RULE_OP_MANGLE_TRUNCATE_AT
:
19204 rule_buf
[rule_pos
] = rule_cmd
;
19205 GET_P0_CONV (rule
);
19208 case RULE_OP_MANGLE_REPLACE
:
19209 rule_buf
[rule_pos
] = rule_cmd
;
19214 case RULE_OP_MANGLE_PURGECHAR
:
19218 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19222 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19223 rule_buf
[rule_pos
] = rule_cmd
;
19224 GET_P0_CONV (rule
);
19227 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19228 rule_buf
[rule_pos
] = rule_cmd
;
19229 GET_P0_CONV (rule
);
19232 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19233 rule_buf
[rule_pos
] = rule_cmd
;
19236 case RULE_OP_MANGLE_SWITCH_FIRST
:
19237 rule_buf
[rule_pos
] = rule_cmd
;
19240 case RULE_OP_MANGLE_SWITCH_LAST
:
19241 rule_buf
[rule_pos
] = rule_cmd
;
19244 case RULE_OP_MANGLE_SWITCH_AT
:
19245 rule_buf
[rule_pos
] = rule_cmd
;
19246 GET_P0_CONV (rule
);
19247 GET_P1_CONV (rule
);
19250 case RULE_OP_MANGLE_CHR_SHIFTL
:
19251 rule_buf
[rule_pos
] = rule_cmd
;
19252 GET_P0_CONV (rule
);
19255 case RULE_OP_MANGLE_CHR_SHIFTR
:
19256 rule_buf
[rule_pos
] = rule_cmd
;
19257 GET_P0_CONV (rule
);
19260 case RULE_OP_MANGLE_CHR_INCR
:
19261 rule_buf
[rule_pos
] = rule_cmd
;
19262 GET_P0_CONV (rule
);
19265 case RULE_OP_MANGLE_CHR_DECR
:
19266 rule_buf
[rule_pos
] = rule_cmd
;
19267 GET_P0_CONV (rule
);
19270 case RULE_OP_MANGLE_REPLACE_NP1
:
19271 rule_buf
[rule_pos
] = rule_cmd
;
19272 GET_P0_CONV (rule
);
19275 case RULE_OP_MANGLE_REPLACE_NM1
:
19276 rule_buf
[rule_pos
] = rule_cmd
;
19277 GET_P0_CONV (rule
);
19280 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19281 rule_buf
[rule_pos
] = rule_cmd
;
19282 GET_P0_CONV (rule
);
19285 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19286 rule_buf
[rule_pos
] = rule_cmd
;
19287 GET_P0_CONV (rule
);
19290 case RULE_OP_MANGLE_TITLE
:
19291 rule_buf
[rule_pos
] = rule_cmd
;
19295 return rule_pos
- 1;
19313 * CPU rules : this is from hashcat sources, cpu based rules
19316 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19317 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19319 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19320 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19321 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19323 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19324 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19325 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19327 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19331 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19336 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19340 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19345 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19349 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19354 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19359 for (l
= 0; l
< arr_len
; l
++)
19361 r
= arr_len
- 1 - l
;
19365 MANGLE_SWITCH (arr
, l
, r
);
19371 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19373 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19375 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19377 return (arr_len
* 2);
19380 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19382 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19384 int orig_len
= arr_len
;
19388 for (i
= 0; i
< times
; i
++)
19390 memcpy (&arr
[arr_len
], arr
, orig_len
);
19392 arr_len
+= orig_len
;
19398 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19400 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19402 mangle_double (arr
, arr_len
);
19404 mangle_reverse (arr
+ arr_len
, arr_len
);
19406 return (arr_len
* 2);
19409 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19414 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19416 MANGLE_SWITCH (arr
, l
, r
);
19422 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19427 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19429 MANGLE_SWITCH (arr
, l
, r
);
19435 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19437 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19441 return (arr_len
+ 1);
19444 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19446 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19450 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19452 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19457 return (arr_len
+ 1);
19460 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19462 if (upos
>= arr_len
) return (arr_len
);
19466 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19468 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19471 return (arr_len
- 1);
19474 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19476 if (upos
>= arr_len
) return (arr_len
);
19478 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19482 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19484 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19490 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19492 if (upos
>= arr_len
) return (arr_len
);
19494 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19498 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19500 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19503 return (arr_len
- ulen
);
19506 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19508 if (upos
>= arr_len
) return (arr_len
);
19510 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19514 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19516 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19521 return (arr_len
+ 1);
19524 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
)
19526 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19528 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19530 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19532 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19534 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19536 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19538 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19540 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19542 return (arr_len
+ arr2_cpy
);
19545 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19547 if (upos
>= arr_len
) return (arr_len
);
19554 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19556 if (upos
>= arr_len
) return (arr_len
);
19558 memset (arr
+ upos
, 0, arr_len
- upos
);
19563 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19567 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19569 if (arr
[arr_pos
] != oldc
) continue;
19571 arr
[arr_pos
] = newc
;
19577 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19583 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19585 if (arr
[arr_pos
] == c
) continue;
19587 arr
[ret_len
] = arr
[arr_pos
];
19595 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19597 if (ulen
> arr_len
) return (arr_len
);
19599 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19603 memcpy (cs
, arr
, ulen
);
19607 for (i
= 0; i
< ulen
; i
++)
19611 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19617 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19619 if (ulen
> arr_len
) return (arr_len
);
19621 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19623 int upos
= arr_len
- ulen
;
19627 for (i
= 0; i
< ulen
; i
++)
19629 char c
= arr
[upos
+ i
];
19631 arr_len
= mangle_append (arr
, arr_len
, c
);
19637 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19639 if ( arr_len
== 0) return (arr_len
);
19640 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19642 char c
= arr
[upos
];
19646 for (i
= 0; i
< ulen
; i
++)
19648 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19654 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19656 if ( arr_len
== 0) return (arr_len
);
19657 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19661 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19663 int new_pos
= arr_pos
* 2;
19665 arr
[new_pos
] = arr
[arr_pos
];
19667 arr
[new_pos
+ 1] = arr
[arr_pos
];
19670 return (arr_len
* 2);
19673 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19675 if (upos
>= arr_len
) return (arr_len
);
19676 if (upos2
>= arr_len
) return (arr_len
);
19678 MANGLE_SWITCH (arr
, upos
, upos2
);
19683 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19685 MANGLE_SWITCH (arr
, upos
, upos2
);
19690 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19692 if (upos
>= arr_len
) return (arr_len
);
19699 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19701 if (upos
>= arr_len
) return (arr_len
);
19708 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19710 if (upos
>= arr_len
) return (arr_len
);
19717 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19719 if (upos
>= arr_len
) return (arr_len
);
19726 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19728 int upper_next
= 1;
19732 for (pos
= 0; pos
< arr_len
; pos
++)
19734 if (arr
[pos
] == ' ')
19745 MANGLE_UPPER_AT (arr
, pos
);
19749 MANGLE_LOWER_AT (arr
, pos
);
19756 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19758 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19762 uint32_t rule_pos
= 0;
19764 for (j
= 0; j
< rp_gen_num
; j
++)
19771 switch ((char) get_random_num (0, 9))
19774 r
= get_random_num (0, sizeof (grp_op_nop
));
19775 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19779 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19780 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19781 p1
= get_random_num (0, sizeof (grp_pos
));
19782 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19786 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19787 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19788 p1
= get_random_num (1, 6);
19789 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19793 r
= get_random_num (0, sizeof (grp_op_chr
));
19794 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19795 p1
= get_random_num (0x20, 0x7e);
19796 rule_buf
[rule_pos
++] = (char) p1
;
19800 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19801 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19802 p1
= get_random_num (0x20, 0x7e);
19803 rule_buf
[rule_pos
++] = (char) p1
;
19804 p2
= get_random_num (0x20, 0x7e);
19806 p2
= get_random_num (0x20, 0x7e);
19807 rule_buf
[rule_pos
++] = (char) p2
;
19811 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19812 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19813 p1
= get_random_num (0, sizeof (grp_pos
));
19814 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19815 p2
= get_random_num (0x20, 0x7e);
19816 rule_buf
[rule_pos
++] = (char) p2
;
19820 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19821 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19822 p1
= get_random_num (0, sizeof (grp_pos
));
19823 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19824 p2
= get_random_num (0, sizeof (grp_pos
));
19826 p2
= get_random_num (0, sizeof (grp_pos
));
19827 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19831 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19832 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19833 p1
= get_random_num (0, sizeof (grp_pos
));
19834 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19835 p2
= get_random_num (1, sizeof (grp_pos
));
19837 p2
= get_random_num (1, sizeof (grp_pos
));
19838 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19842 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19843 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19844 p1
= get_random_num (0, sizeof (grp_pos
));
19845 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19846 p2
= get_random_num (1, sizeof (grp_pos
));
19847 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19848 p3
= get_random_num (0, sizeof (grp_pos
));
19849 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19857 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19859 char mem
[BLOCK_SIZE
];
19861 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19863 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19865 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19867 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19869 int out_len
= in_len
;
19870 int mem_len
= in_len
;
19872 memcpy (out
, in
, out_len
);
19876 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19878 int upos
; int upos2
;
19881 switch (rule
[rule_pos
])
19886 case RULE_OP_MANGLE_NOOP
:
19889 case RULE_OP_MANGLE_LREST
:
19890 out_len
= mangle_lrest (out
, out_len
);
19893 case RULE_OP_MANGLE_UREST
:
19894 out_len
= mangle_urest (out
, out_len
);
19897 case RULE_OP_MANGLE_LREST_UFIRST
:
19898 out_len
= mangle_lrest (out
, out_len
);
19899 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19902 case RULE_OP_MANGLE_UREST_LFIRST
:
19903 out_len
= mangle_urest (out
, out_len
);
19904 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19907 case RULE_OP_MANGLE_TREST
:
19908 out_len
= mangle_trest (out
, out_len
);
19911 case RULE_OP_MANGLE_TOGGLE_AT
:
19912 NEXT_RULEPOS (rule_pos
);
19913 NEXT_RPTOI (rule
, rule_pos
, upos
);
19914 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19917 case RULE_OP_MANGLE_REVERSE
:
19918 out_len
= mangle_reverse (out
, out_len
);
19921 case RULE_OP_MANGLE_DUPEWORD
:
19922 out_len
= mangle_double (out
, out_len
);
19925 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19926 NEXT_RULEPOS (rule_pos
);
19927 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19928 out_len
= mangle_double_times (out
, out_len
, ulen
);
19931 case RULE_OP_MANGLE_REFLECT
:
19932 out_len
= mangle_reflect (out
, out_len
);
19935 case RULE_OP_MANGLE_ROTATE_LEFT
:
19936 mangle_rotate_left (out
, out_len
);
19939 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19940 mangle_rotate_right (out
, out_len
);
19943 case RULE_OP_MANGLE_APPEND
:
19944 NEXT_RULEPOS (rule_pos
);
19945 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19948 case RULE_OP_MANGLE_PREPEND
:
19949 NEXT_RULEPOS (rule_pos
);
19950 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19953 case RULE_OP_MANGLE_DELETE_FIRST
:
19954 out_len
= mangle_delete_at (out
, out_len
, 0);
19957 case RULE_OP_MANGLE_DELETE_LAST
:
19958 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19961 case RULE_OP_MANGLE_DELETE_AT
:
19962 NEXT_RULEPOS (rule_pos
);
19963 NEXT_RPTOI (rule
, rule_pos
, upos
);
19964 out_len
= mangle_delete_at (out
, out_len
, upos
);
19967 case RULE_OP_MANGLE_EXTRACT
:
19968 NEXT_RULEPOS (rule_pos
);
19969 NEXT_RPTOI (rule
, rule_pos
, upos
);
19970 NEXT_RULEPOS (rule_pos
);
19971 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19972 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19975 case RULE_OP_MANGLE_OMIT
:
19976 NEXT_RULEPOS (rule_pos
);
19977 NEXT_RPTOI (rule
, rule_pos
, upos
);
19978 NEXT_RULEPOS (rule_pos
);
19979 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19980 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19983 case RULE_OP_MANGLE_INSERT
:
19984 NEXT_RULEPOS (rule_pos
);
19985 NEXT_RPTOI (rule
, rule_pos
, upos
);
19986 NEXT_RULEPOS (rule_pos
);
19987 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19990 case RULE_OP_MANGLE_OVERSTRIKE
:
19991 NEXT_RULEPOS (rule_pos
);
19992 NEXT_RPTOI (rule
, rule_pos
, upos
);
19993 NEXT_RULEPOS (rule_pos
);
19994 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
19997 case RULE_OP_MANGLE_TRUNCATE_AT
:
19998 NEXT_RULEPOS (rule_pos
);
19999 NEXT_RPTOI (rule
, rule_pos
, upos
);
20000 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20003 case RULE_OP_MANGLE_REPLACE
:
20004 NEXT_RULEPOS (rule_pos
);
20005 NEXT_RULEPOS (rule_pos
);
20006 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20009 case RULE_OP_MANGLE_PURGECHAR
:
20010 NEXT_RULEPOS (rule_pos
);
20011 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20014 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20018 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20019 NEXT_RULEPOS (rule_pos
);
20020 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20021 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20024 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20025 NEXT_RULEPOS (rule_pos
);
20026 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20027 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20030 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20031 out_len
= mangle_dupechar (out
, out_len
);
20034 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20035 NEXT_RULEPOS (rule_pos
);
20036 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20037 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20040 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20041 NEXT_RULEPOS (rule_pos
);
20042 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20043 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20046 case RULE_OP_MANGLE_SWITCH_FIRST
:
20047 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20050 case RULE_OP_MANGLE_SWITCH_LAST
:
20051 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20054 case RULE_OP_MANGLE_SWITCH_AT
:
20055 NEXT_RULEPOS (rule_pos
);
20056 NEXT_RPTOI (rule
, rule_pos
, upos
);
20057 NEXT_RULEPOS (rule_pos
);
20058 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20059 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20062 case RULE_OP_MANGLE_CHR_SHIFTL
:
20063 NEXT_RULEPOS (rule_pos
);
20064 NEXT_RPTOI (rule
, rule_pos
, upos
);
20065 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20068 case RULE_OP_MANGLE_CHR_SHIFTR
:
20069 NEXT_RULEPOS (rule_pos
);
20070 NEXT_RPTOI (rule
, rule_pos
, upos
);
20071 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20074 case RULE_OP_MANGLE_CHR_INCR
:
20075 NEXT_RULEPOS (rule_pos
);
20076 NEXT_RPTOI (rule
, rule_pos
, upos
);
20077 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20080 case RULE_OP_MANGLE_CHR_DECR
:
20081 NEXT_RULEPOS (rule_pos
);
20082 NEXT_RPTOI (rule
, rule_pos
, upos
);
20083 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20086 case RULE_OP_MANGLE_REPLACE_NP1
:
20087 NEXT_RULEPOS (rule_pos
);
20088 NEXT_RPTOI (rule
, rule_pos
, upos
);
20089 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20092 case RULE_OP_MANGLE_REPLACE_NM1
:
20093 NEXT_RULEPOS (rule_pos
);
20094 NEXT_RPTOI (rule
, rule_pos
, upos
);
20095 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20098 case RULE_OP_MANGLE_TITLE
:
20099 out_len
= mangle_title (out
, out_len
);
20102 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20103 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20104 NEXT_RULEPOS (rule_pos
);
20105 NEXT_RPTOI (rule
, rule_pos
, upos
);
20106 NEXT_RULEPOS (rule_pos
);
20107 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20108 NEXT_RULEPOS (rule_pos
);
20109 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20110 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20113 case RULE_OP_MANGLE_APPEND_MEMORY
:
20114 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20115 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20116 memcpy (out
+ out_len
, mem
, mem_len
);
20117 out_len
+= mem_len
;
20120 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20121 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20122 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20123 memcpy (mem
+ mem_len
, out
, out_len
);
20124 out_len
+= mem_len
;
20125 memcpy (out
, mem
, out_len
);
20128 case RULE_OP_MEMORIZE_WORD
:
20129 memcpy (mem
, out
, out_len
);
20133 case RULE_OP_REJECT_LESS
:
20134 NEXT_RULEPOS (rule_pos
);
20135 NEXT_RPTOI (rule
, rule_pos
, upos
);
20136 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20139 case RULE_OP_REJECT_GREATER
:
20140 NEXT_RULEPOS (rule_pos
);
20141 NEXT_RPTOI (rule
, rule_pos
, upos
);
20142 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20145 case RULE_OP_REJECT_CONTAIN
:
20146 NEXT_RULEPOS (rule_pos
);
20147 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20150 case RULE_OP_REJECT_NOT_CONTAIN
:
20151 NEXT_RULEPOS (rule_pos
);
20152 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20155 case RULE_OP_REJECT_EQUAL_FIRST
:
20156 NEXT_RULEPOS (rule_pos
);
20157 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20160 case RULE_OP_REJECT_EQUAL_LAST
:
20161 NEXT_RULEPOS (rule_pos
);
20162 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20165 case RULE_OP_REJECT_EQUAL_AT
:
20166 NEXT_RULEPOS (rule_pos
);
20167 NEXT_RPTOI (rule
, rule_pos
, upos
);
20168 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20169 NEXT_RULEPOS (rule_pos
);
20170 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20173 case RULE_OP_REJECT_CONTAINS
:
20174 NEXT_RULEPOS (rule_pos
);
20175 NEXT_RPTOI (rule
, rule_pos
, upos
);
20176 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20177 NEXT_RULEPOS (rule_pos
);
20178 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20179 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20182 case RULE_OP_REJECT_MEMORY
:
20183 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20187 return (RULE_RC_SYNTAX_ERROR
);
20192 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);