2 * Author......: Jens Steube <jens.steube@gmail.com>
9 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
10 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
16 #define GET_ACCEL(x) GPU_ACCEL_AMD_ ## x
17 #define GET_LOOPS(x) GPU_LOOPS_AMD_ ## x
23 uint32_t rotl32 (const uint32_t a
, const uint n
)
25 return ((a
<< n
) | (a
>> (32 - n
)));
28 uint32_t rotr32 (const uint32_t a
, const uint n
)
30 return ((a
>> n
) | (a
<< (32 - n
)));
33 uint64_t rotl64 (const uint64_t a
, const uint n
)
35 return ((a
<< n
) | (a
>> (64 - n
)));
38 uint64_t rotr64 (const uint64_t a
, const uint n
)
40 return ((a
>> n
) | (a
<< (64 - n
)));
44 * ciphers for use on cpu
51 * hashes for use on cpu
55 #include "cpu-sha256.c"
63 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
69 for (int i
= 0; i
< last_len
; i
++)
79 int max_len
= (int) sizeof (s
);
81 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
83 if (len
> max_len
) len
= max_len
;
85 fwrite (s
, len
, 1, fp
);
92 void log_out_nn (FILE *fp
, const char *fmt
, ...)
94 if (SUPPRESS_OUTPUT
) return;
100 log_final (fp
, fmt
, ap
);
105 void log_info_nn (const char *fmt
, ...)
107 if (SUPPRESS_OUTPUT
) return;
113 log_final (stdout
, fmt
, ap
);
118 void log_error_nn (const char *fmt
, ...)
120 if (SUPPRESS_OUTPUT
) return;
126 log_final (stderr
, fmt
, ap
);
131 void log_out (FILE *fp
, const char *fmt
, ...)
133 if (SUPPRESS_OUTPUT
) return;
139 log_final (fp
, fmt
, ap
);
148 void log_info (const char *fmt
, ...)
150 if (SUPPRESS_OUTPUT
) return;
156 log_final (stdout
, fmt
, ap
);
160 fputc ('\n', stdout
);
165 void log_error (const char *fmt
, ...)
167 if (SUPPRESS_OUTPUT
) return;
169 fputc ('\n', stderr
);
170 fputc ('\n', stderr
);
176 log_final (stderr
, fmt
, ap
);
180 fputc ('\n', stderr
);
181 fputc ('\n', stderr
);
190 uint
byte_swap_32 (const uint n
)
192 return (n
& 0xff000000) >> 24
193 | (n
& 0x00ff0000) >> 8
194 | (n
& 0x0000ff00) << 8
195 | (n
& 0x000000ff) << 24;
198 uint64_t byte_swap_64 (const uint64_t n
)
200 return (n
& 0xff00000000000000ULL
) >> 56
201 | (n
& 0x00ff000000000000ULL
) >> 40
202 | (n
& 0x0000ff0000000000ULL
) >> 24
203 | (n
& 0x000000ff00000000ULL
) >> 8
204 | (n
& 0x00000000ff000000ULL
) << 8
205 | (n
& 0x0000000000ff0000ULL
) << 24
206 | (n
& 0x000000000000ff00ULL
) << 40
207 | (n
& 0x00000000000000ffULL
) << 56;
210 char int_to_base32 (const char c
)
212 static const char tbl
[0x20] =
214 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
215 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
218 return tbl
[(const uint8_t) c
];
221 char base32_to_int (const char c
)
223 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
224 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
229 char int_to_itoa32 (const char c
)
231 static const char tbl
[0x20] =
233 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
234 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
237 return tbl
[(const uint8_t) c
];
240 char itoa32_to_int (const char c
)
242 if ((c
>= '0') && (c
<= '9')) return c
- '0';
243 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
248 char int_to_itoa64 (const char c
)
250 static const char tbl
[0x40] =
252 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
253 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
254 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
255 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
258 return tbl
[(const uint8_t) c
];
261 char itoa64_to_int (const char c
)
263 static const char tbl
[0x100] =
265 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
266 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
267 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
268 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
269 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
270 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
271 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
272 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
273 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
274 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
275 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
276 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
277 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
278 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
279 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
280 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 return tbl
[(const uint8_t) c
];
286 char int_to_base64 (const char c
)
288 static const char tbl
[0x40] =
290 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
291 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
292 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
293 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
296 return tbl
[(const uint8_t) c
];
299 char base64_to_int (const char c
)
301 static const char tbl
[0x100] =
303 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
306 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
308 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
310 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 return tbl
[(const uint8_t) c
];
324 char int_to_bf64 (const char c
)
326 static const char tbl
[0x40] =
328 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
329 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
330 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
331 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
334 return tbl
[(const uint8_t) c
];
337 char bf64_to_int (const char c
)
339 static const char tbl
[0x100] =
341 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
344 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
346 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
348 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 return tbl
[(const uint8_t) c
];
362 char int_to_lotus64 (const char c
)
364 if (c
< 10) return '0' + c
;
365 else if (c
< 36) return 'A' + c
- 10;
366 else if (c
< 62) return 'a' + c
- 36;
367 else if (c
== 62) return '+';
368 else if (c
== 63) return '/';
373 char lotus64_to_int (const char c
)
375 if ((c
>= '0') && (c
<= '9')) return c
- '0';
376 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
377 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
378 else if (c
== '+') return 62;
379 else if (c
== '/') return 63;
385 int base32_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
387 char *in_ptr
= in_buf
;
389 char *out_ptr
= out_buf
;
391 for (int i
= 0; i
< in_len
; i
+= 8)
393 char out_val0
= f (in_ptr
[0] & 0x7f);
394 char out_val1
= f (in_ptr
[1] & 0x7f);
395 char out_val2
= f (in_ptr
[2] & 0x7f);
396 char out_val3
= f (in_ptr
[3] & 0x7f);
397 char out_val4
= f (in_ptr
[4] & 0x7f);
398 char out_val5
= f (in_ptr
[5] & 0x7f);
399 char out_val6
= f (in_ptr
[6] & 0x7f);
400 char out_val7
= f (in_ptr
[7] & 0x7f);
402 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
403 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
404 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
405 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
406 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
412 for (int i
= 0; i
< in_len
; i
++)
414 if (in_buf
[i
] != '=') continue;
419 int out_len
= (in_len
* 5) / 8;
424 int base32_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
426 char *in_ptr
= in_buf
;
428 char *out_ptr
= out_buf
;
430 for (int i
= 0; i
< in_len
; i
+= 5)
432 char out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
433 char out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
434 char out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
435 char out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
436 char out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
437 char out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
438 char out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
439 char out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
441 out_ptr
[0] = out_val0
& 0x7f;
442 out_ptr
[1] = out_val1
& 0x7f;
443 out_ptr
[2] = out_val2
& 0x7f;
444 out_ptr
[3] = out_val3
& 0x7f;
445 out_ptr
[4] = out_val4
& 0x7f;
446 out_ptr
[5] = out_val5
& 0x7f;
447 out_ptr
[6] = out_val6
& 0x7f;
448 out_ptr
[7] = out_val7
& 0x7f;
454 int out_len
= (in_len
* 8) / 5;
456 for (int i
= 0; i
< (7 - (in_len
% 7)); i
++)
460 out_buf
[out_len
] = '=';
466 int base64_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
468 char *in_ptr
= in_buf
;
470 char *out_ptr
= out_buf
;
472 for (int i
= 0; i
< in_len
; i
+= 4)
474 char out_val0
= f (in_ptr
[0] & 0x7f);
475 char out_val1
= f (in_ptr
[1] & 0x7f);
476 char out_val2
= f (in_ptr
[2] & 0x7f);
477 char out_val3
= f (in_ptr
[3] & 0x7f);
479 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
480 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
481 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
487 for (int i
= 0; i
< in_len
; i
++)
489 if (in_buf
[i
] != '=') continue;
494 int out_len
= (in_len
* 6) / 8;
499 int base64_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
501 char *in_ptr
= in_buf
;
503 char *out_ptr
= out_buf
;
505 for (int i
= 0; i
< in_len
; i
+= 3)
507 char out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
508 char out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
509 char out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
510 char out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
512 out_ptr
[0] = out_val0
& 0x7f;
513 out_ptr
[1] = out_val1
& 0x7f;
514 out_ptr
[2] = out_val2
& 0x7f;
515 out_ptr
[3] = out_val3
& 0x7f;
521 int out_len
= (in_len
* 8) / 6;
523 for (int i
= 0; i
< (3 - (in_len
% 3)); i
++)
527 out_buf
[out_len
] = '=';
533 static void AES128_decrypt_cbc (const uint key
[4], const uint iv
[4], const uint in
[16], uint out
[16])
537 AES_set_decrypt_key ((unsigned char *) key
, 128, &skey
);
546 for (int i
= 0; i
< 16; i
+= 4)
556 AES_decrypt (&skey
, (char *) _in
, (char *) _out
);
563 out
[i
+ 0] = _out
[0];
564 out
[i
+ 1] = _out
[1];
565 out
[i
+ 2] = _out
[2];
566 out
[i
+ 3] = _out
[3];
575 static void juniper_decrypt_hash (char *in
, char *out
)
579 char base64_buf
[100];
581 memset (base64_buf
, 0, sizeof (base64_buf
));
583 base64_decode (base64_to_int
, in
, DISPLAY_LEN_MIN_501
, base64_buf
);
587 uint juniper_iv
[4] = { 0 };
589 memcpy (juniper_iv
, base64_buf
, 12);
591 memcpy (out
, juniper_iv
, 12);
597 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
598 juniper_key
[1] = byte_swap_32 (0x8df91059);
599 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
600 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
604 uint
*in_ptr
= (uint
*) (base64_buf
+ 12);
605 uint
*out_ptr
= (uint
*) (out
+ 12);
607 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
610 uint
is_valid_hex_char (const char c
)
612 if ((c
>= '0') && (c
<= '9')) return 1;
613 if ((c
>= 'A') && (c
<= 'F')) return 1;
614 if ((c
>= 'a') && (c
<= 'f')) return 1;
619 char hex_convert (const char c
)
621 return (c
& 15) + (c
>> 6) * 9;
624 char hex_to_char (const char hex
[2])
628 v
|= (hex_convert (hex
[1]) << 0);
629 v
|= (hex_convert (hex
[0]) << 4);
634 uint
hex_to_uint (const char hex
[8])
638 v
|= hex_convert (hex
[7]) << 0;
639 v
|= hex_convert (hex
[6]) << 4;
640 v
|= hex_convert (hex
[5]) << 8;
641 v
|= hex_convert (hex
[4]) << 12;
642 v
|= hex_convert (hex
[3]) << 16;
643 v
|= hex_convert (hex
[2]) << 20;
644 v
|= hex_convert (hex
[1]) << 24;
645 v
|= hex_convert (hex
[0]) << 28;
650 uint64_t hex_to_uint64_t (const char hex
[16])
654 v
|= ((uint64_t) hex_convert (hex
[15]) << 0);
655 v
|= ((uint64_t) hex_convert (hex
[14]) << 4);
656 v
|= ((uint64_t) hex_convert (hex
[13]) << 8);
657 v
|= ((uint64_t) hex_convert (hex
[12]) << 12);
658 v
|= ((uint64_t) hex_convert (hex
[11]) << 16);
659 v
|= ((uint64_t) hex_convert (hex
[10]) << 20);
660 v
|= ((uint64_t) hex_convert (hex
[ 9]) << 24);
661 v
|= ((uint64_t) hex_convert (hex
[ 8]) << 28);
662 v
|= ((uint64_t) hex_convert (hex
[ 7]) << 32);
663 v
|= ((uint64_t) hex_convert (hex
[ 6]) << 36);
664 v
|= ((uint64_t) hex_convert (hex
[ 5]) << 40);
665 v
|= ((uint64_t) hex_convert (hex
[ 4]) << 44);
666 v
|= ((uint64_t) hex_convert (hex
[ 3]) << 48);
667 v
|= ((uint64_t) hex_convert (hex
[ 2]) << 52);
668 v
|= ((uint64_t) hex_convert (hex
[ 1]) << 56);
669 v
|= ((uint64_t) hex_convert (hex
[ 0]) << 60);
674 void bin_to_hex_lower (uint v
, char hex
[8])
676 hex
[0] = v
>> 28 & 15;
677 hex
[1] = v
>> 24 & 15;
678 hex
[2] = v
>> 20 & 15;
679 hex
[3] = v
>> 16 & 15;
680 hex
[4] = v
>> 12 & 15;
681 hex
[5] = v
>> 8 & 15;
682 hex
[6] = v
>> 4 & 15;
683 hex
[7] = v
>> 0 & 15;
687 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
688 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
689 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
690 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
691 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
692 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
693 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
694 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
697 void phpass_decode (unsigned char digest
[16], unsigned char buf
[22])
701 l
= itoa64_to_int (buf
[ 0]) << 0;
702 l
|= itoa64_to_int (buf
[ 1]) << 6;
703 l
|= itoa64_to_int (buf
[ 2]) << 12;
704 l
|= itoa64_to_int (buf
[ 3]) << 18;
706 digest
[ 0] = (l
>> 0) & 0xff;
707 digest
[ 1] = (l
>> 8) & 0xff;
708 digest
[ 2] = (l
>> 16) & 0xff;
710 l
= itoa64_to_int (buf
[ 4]) << 0;
711 l
|= itoa64_to_int (buf
[ 5]) << 6;
712 l
|= itoa64_to_int (buf
[ 6]) << 12;
713 l
|= itoa64_to_int (buf
[ 7]) << 18;
715 digest
[ 3] = (l
>> 0) & 0xff;
716 digest
[ 4] = (l
>> 8) & 0xff;
717 digest
[ 5] = (l
>> 16) & 0xff;
719 l
= itoa64_to_int (buf
[ 8]) << 0;
720 l
|= itoa64_to_int (buf
[ 9]) << 6;
721 l
|= itoa64_to_int (buf
[10]) << 12;
722 l
|= itoa64_to_int (buf
[11]) << 18;
724 digest
[ 6] = (l
>> 0) & 0xff;
725 digest
[ 7] = (l
>> 8) & 0xff;
726 digest
[ 8] = (l
>> 16) & 0xff;
728 l
= itoa64_to_int (buf
[12]) << 0;
729 l
|= itoa64_to_int (buf
[13]) << 6;
730 l
|= itoa64_to_int (buf
[14]) << 12;
731 l
|= itoa64_to_int (buf
[15]) << 18;
733 digest
[ 9] = (l
>> 0) & 0xff;
734 digest
[10] = (l
>> 8) & 0xff;
735 digest
[11] = (l
>> 16) & 0xff;
737 l
= itoa64_to_int (buf
[16]) << 0;
738 l
|= itoa64_to_int (buf
[17]) << 6;
739 l
|= itoa64_to_int (buf
[18]) << 12;
740 l
|= itoa64_to_int (buf
[19]) << 18;
742 digest
[12] = (l
>> 0) & 0xff;
743 digest
[13] = (l
>> 8) & 0xff;
744 digest
[14] = (l
>> 16) & 0xff;
746 l
= itoa64_to_int (buf
[20]) << 0;
747 l
|= itoa64_to_int (buf
[21]) << 6;
749 digest
[15] = (l
>> 0) & 0xff;
752 void phpass_encode (unsigned char digest
[16], unsigned char buf
[22])
756 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
758 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
759 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
760 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
761 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
763 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
765 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
770 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
772 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[11] = int_to_itoa64 (l
& 0x3f);
777 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
779 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[15] = int_to_itoa64 (l
& 0x3f);
784 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
786 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[19] = int_to_itoa64 (l
& 0x3f);
791 l
= (digest
[15] << 0);
793 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[21] = int_to_itoa64 (l
& 0x3f);
797 void md5crypt_decode (unsigned char digest
[16], unsigned char buf
[22])
801 l
= itoa64_to_int (buf
[ 0]) << 0;
802 l
|= itoa64_to_int (buf
[ 1]) << 6;
803 l
|= itoa64_to_int (buf
[ 2]) << 12;
804 l
|= itoa64_to_int (buf
[ 3]) << 18;
806 digest
[ 0] = (l
>> 16) & 0xff;
807 digest
[ 6] = (l
>> 8) & 0xff;
808 digest
[12] = (l
>> 0) & 0xff;
810 l
= itoa64_to_int (buf
[ 4]) << 0;
811 l
|= itoa64_to_int (buf
[ 5]) << 6;
812 l
|= itoa64_to_int (buf
[ 6]) << 12;
813 l
|= itoa64_to_int (buf
[ 7]) << 18;
815 digest
[ 1] = (l
>> 16) & 0xff;
816 digest
[ 7] = (l
>> 8) & 0xff;
817 digest
[13] = (l
>> 0) & 0xff;
819 l
= itoa64_to_int (buf
[ 8]) << 0;
820 l
|= itoa64_to_int (buf
[ 9]) << 6;
821 l
|= itoa64_to_int (buf
[10]) << 12;
822 l
|= itoa64_to_int (buf
[11]) << 18;
824 digest
[ 2] = (l
>> 16) & 0xff;
825 digest
[ 8] = (l
>> 8) & 0xff;
826 digest
[14] = (l
>> 0) & 0xff;
828 l
= itoa64_to_int (buf
[12]) << 0;
829 l
|= itoa64_to_int (buf
[13]) << 6;
830 l
|= itoa64_to_int (buf
[14]) << 12;
831 l
|= itoa64_to_int (buf
[15]) << 18;
833 digest
[ 3] = (l
>> 16) & 0xff;
834 digest
[ 9] = (l
>> 8) & 0xff;
835 digest
[15] = (l
>> 0) & 0xff;
837 l
= itoa64_to_int (buf
[16]) << 0;
838 l
|= itoa64_to_int (buf
[17]) << 6;
839 l
|= itoa64_to_int (buf
[18]) << 12;
840 l
|= itoa64_to_int (buf
[19]) << 18;
842 digest
[ 4] = (l
>> 16) & 0xff;
843 digest
[10] = (l
>> 8) & 0xff;
844 digest
[ 5] = (l
>> 0) & 0xff;
846 l
= itoa64_to_int (buf
[20]) << 0;
847 l
|= itoa64_to_int (buf
[21]) << 6;
849 digest
[11] = (l
>> 0) & 0xff;
852 void md5crypt_encode (unsigned char digest
[16], unsigned char buf
[22])
856 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
858 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
859 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
860 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
865 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
872 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
879 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
886 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 l
= (digest
[11] << 0);
893 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 void sha512crypt_decode (unsigned char digest
[64], unsigned char buf
[86])
901 l
= itoa64_to_int (buf
[ 0]) << 0;
902 l
|= itoa64_to_int (buf
[ 1]) << 6;
903 l
|= itoa64_to_int (buf
[ 2]) << 12;
904 l
|= itoa64_to_int (buf
[ 3]) << 18;
906 digest
[ 0] = (l
>> 16) & 0xff;
907 digest
[21] = (l
>> 8) & 0xff;
908 digest
[42] = (l
>> 0) & 0xff;
910 l
= itoa64_to_int (buf
[ 4]) << 0;
911 l
|= itoa64_to_int (buf
[ 5]) << 6;
912 l
|= itoa64_to_int (buf
[ 6]) << 12;
913 l
|= itoa64_to_int (buf
[ 7]) << 18;
915 digest
[22] = (l
>> 16) & 0xff;
916 digest
[43] = (l
>> 8) & 0xff;
917 digest
[ 1] = (l
>> 0) & 0xff;
919 l
= itoa64_to_int (buf
[ 8]) << 0;
920 l
|= itoa64_to_int (buf
[ 9]) << 6;
921 l
|= itoa64_to_int (buf
[10]) << 12;
922 l
|= itoa64_to_int (buf
[11]) << 18;
924 digest
[44] = (l
>> 16) & 0xff;
925 digest
[ 2] = (l
>> 8) & 0xff;
926 digest
[23] = (l
>> 0) & 0xff;
928 l
= itoa64_to_int (buf
[12]) << 0;
929 l
|= itoa64_to_int (buf
[13]) << 6;
930 l
|= itoa64_to_int (buf
[14]) << 12;
931 l
|= itoa64_to_int (buf
[15]) << 18;
933 digest
[ 3] = (l
>> 16) & 0xff;
934 digest
[24] = (l
>> 8) & 0xff;
935 digest
[45] = (l
>> 0) & 0xff;
937 l
= itoa64_to_int (buf
[16]) << 0;
938 l
|= itoa64_to_int (buf
[17]) << 6;
939 l
|= itoa64_to_int (buf
[18]) << 12;
940 l
|= itoa64_to_int (buf
[19]) << 18;
942 digest
[25] = (l
>> 16) & 0xff;
943 digest
[46] = (l
>> 8) & 0xff;
944 digest
[ 4] = (l
>> 0) & 0xff;
946 l
= itoa64_to_int (buf
[20]) << 0;
947 l
|= itoa64_to_int (buf
[21]) << 6;
948 l
|= itoa64_to_int (buf
[22]) << 12;
949 l
|= itoa64_to_int (buf
[23]) << 18;
951 digest
[47] = (l
>> 16) & 0xff;
952 digest
[ 5] = (l
>> 8) & 0xff;
953 digest
[26] = (l
>> 0) & 0xff;
955 l
= itoa64_to_int (buf
[24]) << 0;
956 l
|= itoa64_to_int (buf
[25]) << 6;
957 l
|= itoa64_to_int (buf
[26]) << 12;
958 l
|= itoa64_to_int (buf
[27]) << 18;
960 digest
[ 6] = (l
>> 16) & 0xff;
961 digest
[27] = (l
>> 8) & 0xff;
962 digest
[48] = (l
>> 0) & 0xff;
964 l
= itoa64_to_int (buf
[28]) << 0;
965 l
|= itoa64_to_int (buf
[29]) << 6;
966 l
|= itoa64_to_int (buf
[30]) << 12;
967 l
|= itoa64_to_int (buf
[31]) << 18;
969 digest
[28] = (l
>> 16) & 0xff;
970 digest
[49] = (l
>> 8) & 0xff;
971 digest
[ 7] = (l
>> 0) & 0xff;
973 l
= itoa64_to_int (buf
[32]) << 0;
974 l
|= itoa64_to_int (buf
[33]) << 6;
975 l
|= itoa64_to_int (buf
[34]) << 12;
976 l
|= itoa64_to_int (buf
[35]) << 18;
978 digest
[50] = (l
>> 16) & 0xff;
979 digest
[ 8] = (l
>> 8) & 0xff;
980 digest
[29] = (l
>> 0) & 0xff;
982 l
= itoa64_to_int (buf
[36]) << 0;
983 l
|= itoa64_to_int (buf
[37]) << 6;
984 l
|= itoa64_to_int (buf
[38]) << 12;
985 l
|= itoa64_to_int (buf
[39]) << 18;
987 digest
[ 9] = (l
>> 16) & 0xff;
988 digest
[30] = (l
>> 8) & 0xff;
989 digest
[51] = (l
>> 0) & 0xff;
991 l
= itoa64_to_int (buf
[40]) << 0;
992 l
|= itoa64_to_int (buf
[41]) << 6;
993 l
|= itoa64_to_int (buf
[42]) << 12;
994 l
|= itoa64_to_int (buf
[43]) << 18;
996 digest
[31] = (l
>> 16) & 0xff;
997 digest
[52] = (l
>> 8) & 0xff;
998 digest
[10] = (l
>> 0) & 0xff;
1000 l
= itoa64_to_int (buf
[44]) << 0;
1001 l
|= itoa64_to_int (buf
[45]) << 6;
1002 l
|= itoa64_to_int (buf
[46]) << 12;
1003 l
|= itoa64_to_int (buf
[47]) << 18;
1005 digest
[53] = (l
>> 16) & 0xff;
1006 digest
[11] = (l
>> 8) & 0xff;
1007 digest
[32] = (l
>> 0) & 0xff;
1009 l
= itoa64_to_int (buf
[48]) << 0;
1010 l
|= itoa64_to_int (buf
[49]) << 6;
1011 l
|= itoa64_to_int (buf
[50]) << 12;
1012 l
|= itoa64_to_int (buf
[51]) << 18;
1014 digest
[12] = (l
>> 16) & 0xff;
1015 digest
[33] = (l
>> 8) & 0xff;
1016 digest
[54] = (l
>> 0) & 0xff;
1018 l
= itoa64_to_int (buf
[52]) << 0;
1019 l
|= itoa64_to_int (buf
[53]) << 6;
1020 l
|= itoa64_to_int (buf
[54]) << 12;
1021 l
|= itoa64_to_int (buf
[55]) << 18;
1023 digest
[34] = (l
>> 16) & 0xff;
1024 digest
[55] = (l
>> 8) & 0xff;
1025 digest
[13] = (l
>> 0) & 0xff;
1027 l
= itoa64_to_int (buf
[56]) << 0;
1028 l
|= itoa64_to_int (buf
[57]) << 6;
1029 l
|= itoa64_to_int (buf
[58]) << 12;
1030 l
|= itoa64_to_int (buf
[59]) << 18;
1032 digest
[56] = (l
>> 16) & 0xff;
1033 digest
[14] = (l
>> 8) & 0xff;
1034 digest
[35] = (l
>> 0) & 0xff;
1036 l
= itoa64_to_int (buf
[60]) << 0;
1037 l
|= itoa64_to_int (buf
[61]) << 6;
1038 l
|= itoa64_to_int (buf
[62]) << 12;
1039 l
|= itoa64_to_int (buf
[63]) << 18;
1041 digest
[15] = (l
>> 16) & 0xff;
1042 digest
[36] = (l
>> 8) & 0xff;
1043 digest
[57] = (l
>> 0) & 0xff;
1045 l
= itoa64_to_int (buf
[64]) << 0;
1046 l
|= itoa64_to_int (buf
[65]) << 6;
1047 l
|= itoa64_to_int (buf
[66]) << 12;
1048 l
|= itoa64_to_int (buf
[67]) << 18;
1050 digest
[37] = (l
>> 16) & 0xff;
1051 digest
[58] = (l
>> 8) & 0xff;
1052 digest
[16] = (l
>> 0) & 0xff;
1054 l
= itoa64_to_int (buf
[68]) << 0;
1055 l
|= itoa64_to_int (buf
[69]) << 6;
1056 l
|= itoa64_to_int (buf
[70]) << 12;
1057 l
|= itoa64_to_int (buf
[71]) << 18;
1059 digest
[59] = (l
>> 16) & 0xff;
1060 digest
[17] = (l
>> 8) & 0xff;
1061 digest
[38] = (l
>> 0) & 0xff;
1063 l
= itoa64_to_int (buf
[72]) << 0;
1064 l
|= itoa64_to_int (buf
[73]) << 6;
1065 l
|= itoa64_to_int (buf
[74]) << 12;
1066 l
|= itoa64_to_int (buf
[75]) << 18;
1068 digest
[18] = (l
>> 16) & 0xff;
1069 digest
[39] = (l
>> 8) & 0xff;
1070 digest
[60] = (l
>> 0) & 0xff;
1072 l
= itoa64_to_int (buf
[76]) << 0;
1073 l
|= itoa64_to_int (buf
[77]) << 6;
1074 l
|= itoa64_to_int (buf
[78]) << 12;
1075 l
|= itoa64_to_int (buf
[79]) << 18;
1077 digest
[40] = (l
>> 16) & 0xff;
1078 digest
[61] = (l
>> 8) & 0xff;
1079 digest
[19] = (l
>> 0) & 0xff;
1081 l
= itoa64_to_int (buf
[80]) << 0;
1082 l
|= itoa64_to_int (buf
[81]) << 6;
1083 l
|= itoa64_to_int (buf
[82]) << 12;
1084 l
|= itoa64_to_int (buf
[83]) << 18;
1086 digest
[62] = (l
>> 16) & 0xff;
1087 digest
[20] = (l
>> 8) & 0xff;
1088 digest
[41] = (l
>> 0) & 0xff;
1090 l
= itoa64_to_int (buf
[84]) << 0;
1091 l
|= itoa64_to_int (buf
[85]) << 6;
1093 digest
[63] = (l
>> 0) & 0xff;
1096 void sha512crypt_encode (unsigned char digest
[64], unsigned char buf
[86])
1100 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1102 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1103 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1104 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1109 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1116 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1123 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1130 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1137 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1144 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1151 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1158 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1165 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1172 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1179 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1186 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1193 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1200 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1207 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1214 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1221 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1228 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1235 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1242 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 l
= 0 | 0 | (digest
[63] << 0);
1249 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 void sha1aix_decode (unsigned char digest
[20], unsigned char buf
[27])
1257 l
= itoa64_to_int (buf
[ 0]) << 0;
1258 l
|= itoa64_to_int (buf
[ 1]) << 6;
1259 l
|= itoa64_to_int (buf
[ 2]) << 12;
1260 l
|= itoa64_to_int (buf
[ 3]) << 18;
1262 digest
[ 2] = (l
>> 0) & 0xff;
1263 digest
[ 1] = (l
>> 8) & 0xff;
1264 digest
[ 0] = (l
>> 16) & 0xff;
1266 l
= itoa64_to_int (buf
[ 4]) << 0;
1267 l
|= itoa64_to_int (buf
[ 5]) << 6;
1268 l
|= itoa64_to_int (buf
[ 6]) << 12;
1269 l
|= itoa64_to_int (buf
[ 7]) << 18;
1271 digest
[ 5] = (l
>> 0) & 0xff;
1272 digest
[ 4] = (l
>> 8) & 0xff;
1273 digest
[ 3] = (l
>> 16) & 0xff;
1275 l
= itoa64_to_int (buf
[ 8]) << 0;
1276 l
|= itoa64_to_int (buf
[ 9]) << 6;
1277 l
|= itoa64_to_int (buf
[10]) << 12;
1278 l
|= itoa64_to_int (buf
[11]) << 18;
1280 digest
[ 8] = (l
>> 0) & 0xff;
1281 digest
[ 7] = (l
>> 8) & 0xff;
1282 digest
[ 6] = (l
>> 16) & 0xff;
1284 l
= itoa64_to_int (buf
[12]) << 0;
1285 l
|= itoa64_to_int (buf
[13]) << 6;
1286 l
|= itoa64_to_int (buf
[14]) << 12;
1287 l
|= itoa64_to_int (buf
[15]) << 18;
1289 digest
[11] = (l
>> 0) & 0xff;
1290 digest
[10] = (l
>> 8) & 0xff;
1291 digest
[ 9] = (l
>> 16) & 0xff;
1293 l
= itoa64_to_int (buf
[16]) << 0;
1294 l
|= itoa64_to_int (buf
[17]) << 6;
1295 l
|= itoa64_to_int (buf
[18]) << 12;
1296 l
|= itoa64_to_int (buf
[19]) << 18;
1298 digest
[14] = (l
>> 0) & 0xff;
1299 digest
[13] = (l
>> 8) & 0xff;
1300 digest
[12] = (l
>> 16) & 0xff;
1302 l
= itoa64_to_int (buf
[20]) << 0;
1303 l
|= itoa64_to_int (buf
[21]) << 6;
1304 l
|= itoa64_to_int (buf
[22]) << 12;
1305 l
|= itoa64_to_int (buf
[23]) << 18;
1307 digest
[17] = (l
>> 0) & 0xff;
1308 digest
[16] = (l
>> 8) & 0xff;
1309 digest
[15] = (l
>> 16) & 0xff;
1311 l
= itoa64_to_int (buf
[24]) << 0;
1312 l
|= itoa64_to_int (buf
[25]) << 6;
1313 l
|= itoa64_to_int (buf
[26]) << 12;
1315 digest
[19] = (l
>> 8) & 0xff;
1316 digest
[18] = (l
>> 16) & 0xff;
1319 void sha1aix_encode (unsigned char digest
[20], unsigned char buf
[27])
1323 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1325 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1326 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1327 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1328 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1330 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1332 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1337 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1339 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[11] = int_to_itoa64 (l
& 0x3f);
1344 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1346 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[15] = int_to_itoa64 (l
& 0x3f);
1351 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1353 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[19] = int_to_itoa64 (l
& 0x3f);
1358 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1360 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[23] = int_to_itoa64 (l
& 0x3f);
1365 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1367 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[26] = int_to_itoa64 (l
& 0x3f);
1372 void sha256aix_decode (unsigned char digest
[32], unsigned char buf
[43])
1376 l
= itoa64_to_int (buf
[ 0]) << 0;
1377 l
|= itoa64_to_int (buf
[ 1]) << 6;
1378 l
|= itoa64_to_int (buf
[ 2]) << 12;
1379 l
|= itoa64_to_int (buf
[ 3]) << 18;
1381 digest
[ 2] = (l
>> 0) & 0xff;
1382 digest
[ 1] = (l
>> 8) & 0xff;
1383 digest
[ 0] = (l
>> 16) & 0xff;
1385 l
= itoa64_to_int (buf
[ 4]) << 0;
1386 l
|= itoa64_to_int (buf
[ 5]) << 6;
1387 l
|= itoa64_to_int (buf
[ 6]) << 12;
1388 l
|= itoa64_to_int (buf
[ 7]) << 18;
1390 digest
[ 5] = (l
>> 0) & 0xff;
1391 digest
[ 4] = (l
>> 8) & 0xff;
1392 digest
[ 3] = (l
>> 16) & 0xff;
1394 l
= itoa64_to_int (buf
[ 8]) << 0;
1395 l
|= itoa64_to_int (buf
[ 9]) << 6;
1396 l
|= itoa64_to_int (buf
[10]) << 12;
1397 l
|= itoa64_to_int (buf
[11]) << 18;
1399 digest
[ 8] = (l
>> 0) & 0xff;
1400 digest
[ 7] = (l
>> 8) & 0xff;
1401 digest
[ 6] = (l
>> 16) & 0xff;
1403 l
= itoa64_to_int (buf
[12]) << 0;
1404 l
|= itoa64_to_int (buf
[13]) << 6;
1405 l
|= itoa64_to_int (buf
[14]) << 12;
1406 l
|= itoa64_to_int (buf
[15]) << 18;
1408 digest
[11] = (l
>> 0) & 0xff;
1409 digest
[10] = (l
>> 8) & 0xff;
1410 digest
[ 9] = (l
>> 16) & 0xff;
1412 l
= itoa64_to_int (buf
[16]) << 0;
1413 l
|= itoa64_to_int (buf
[17]) << 6;
1414 l
|= itoa64_to_int (buf
[18]) << 12;
1415 l
|= itoa64_to_int (buf
[19]) << 18;
1417 digest
[14] = (l
>> 0) & 0xff;
1418 digest
[13] = (l
>> 8) & 0xff;
1419 digest
[12] = (l
>> 16) & 0xff;
1421 l
= itoa64_to_int (buf
[20]) << 0;
1422 l
|= itoa64_to_int (buf
[21]) << 6;
1423 l
|= itoa64_to_int (buf
[22]) << 12;
1424 l
|= itoa64_to_int (buf
[23]) << 18;
1426 digest
[17] = (l
>> 0) & 0xff;
1427 digest
[16] = (l
>> 8) & 0xff;
1428 digest
[15] = (l
>> 16) & 0xff;
1430 l
= itoa64_to_int (buf
[24]) << 0;
1431 l
|= itoa64_to_int (buf
[25]) << 6;
1432 l
|= itoa64_to_int (buf
[26]) << 12;
1433 l
|= itoa64_to_int (buf
[27]) << 18;
1435 digest
[20] = (l
>> 0) & 0xff;
1436 digest
[19] = (l
>> 8) & 0xff;
1437 digest
[18] = (l
>> 16) & 0xff;
1439 l
= itoa64_to_int (buf
[28]) << 0;
1440 l
|= itoa64_to_int (buf
[29]) << 6;
1441 l
|= itoa64_to_int (buf
[30]) << 12;
1442 l
|= itoa64_to_int (buf
[31]) << 18;
1444 digest
[23] = (l
>> 0) & 0xff;
1445 digest
[22] = (l
>> 8) & 0xff;
1446 digest
[21] = (l
>> 16) & 0xff;
1448 l
= itoa64_to_int (buf
[32]) << 0;
1449 l
|= itoa64_to_int (buf
[33]) << 6;
1450 l
|= itoa64_to_int (buf
[34]) << 12;
1451 l
|= itoa64_to_int (buf
[35]) << 18;
1453 digest
[26] = (l
>> 0) & 0xff;
1454 digest
[25] = (l
>> 8) & 0xff;
1455 digest
[24] = (l
>> 16) & 0xff;
1457 l
= itoa64_to_int (buf
[36]) << 0;
1458 l
|= itoa64_to_int (buf
[37]) << 6;
1459 l
|= itoa64_to_int (buf
[38]) << 12;
1460 l
|= itoa64_to_int (buf
[39]) << 18;
1462 digest
[29] = (l
>> 0) & 0xff;
1463 digest
[28] = (l
>> 8) & 0xff;
1464 digest
[27] = (l
>> 16) & 0xff;
1466 l
= itoa64_to_int (buf
[40]) << 0;
1467 l
|= itoa64_to_int (buf
[41]) << 6;
1468 l
|= itoa64_to_int (buf
[42]) << 12;
1470 //digest[32] = (l >> 0) & 0xff;
1471 digest
[31] = (l
>> 8) & 0xff;
1472 digest
[30] = (l
>> 16) & 0xff;
1475 void sha256aix_encode (unsigned char digest
[32], unsigned char buf
[43])
1479 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1481 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1482 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1483 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1484 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1486 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1488 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1493 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1495 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[11] = int_to_itoa64 (l
& 0x3f);
1500 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1502 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[15] = int_to_itoa64 (l
& 0x3f);
1507 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1509 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[19] = int_to_itoa64 (l
& 0x3f);
1514 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1516 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[23] = int_to_itoa64 (l
& 0x3f);
1521 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1523 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[27] = int_to_itoa64 (l
& 0x3f);
1528 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1530 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[31] = int_to_itoa64 (l
& 0x3f);
1535 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1537 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[35] = int_to_itoa64 (l
& 0x3f);
1542 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1544 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[39] = int_to_itoa64 (l
& 0x3f);
1549 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1551 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[42] = int_to_itoa64 (l
& 0x3f);
1556 void sha512aix_decode (unsigned char digest
[64], unsigned char buf
[86])
1560 l
= itoa64_to_int (buf
[ 0]) << 0;
1561 l
|= itoa64_to_int (buf
[ 1]) << 6;
1562 l
|= itoa64_to_int (buf
[ 2]) << 12;
1563 l
|= itoa64_to_int (buf
[ 3]) << 18;
1565 digest
[ 2] = (l
>> 0) & 0xff;
1566 digest
[ 1] = (l
>> 8) & 0xff;
1567 digest
[ 0] = (l
>> 16) & 0xff;
1569 l
= itoa64_to_int (buf
[ 4]) << 0;
1570 l
|= itoa64_to_int (buf
[ 5]) << 6;
1571 l
|= itoa64_to_int (buf
[ 6]) << 12;
1572 l
|= itoa64_to_int (buf
[ 7]) << 18;
1574 digest
[ 5] = (l
>> 0) & 0xff;
1575 digest
[ 4] = (l
>> 8) & 0xff;
1576 digest
[ 3] = (l
>> 16) & 0xff;
1578 l
= itoa64_to_int (buf
[ 8]) << 0;
1579 l
|= itoa64_to_int (buf
[ 9]) << 6;
1580 l
|= itoa64_to_int (buf
[10]) << 12;
1581 l
|= itoa64_to_int (buf
[11]) << 18;
1583 digest
[ 8] = (l
>> 0) & 0xff;
1584 digest
[ 7] = (l
>> 8) & 0xff;
1585 digest
[ 6] = (l
>> 16) & 0xff;
1587 l
= itoa64_to_int (buf
[12]) << 0;
1588 l
|= itoa64_to_int (buf
[13]) << 6;
1589 l
|= itoa64_to_int (buf
[14]) << 12;
1590 l
|= itoa64_to_int (buf
[15]) << 18;
1592 digest
[11] = (l
>> 0) & 0xff;
1593 digest
[10] = (l
>> 8) & 0xff;
1594 digest
[ 9] = (l
>> 16) & 0xff;
1596 l
= itoa64_to_int (buf
[16]) << 0;
1597 l
|= itoa64_to_int (buf
[17]) << 6;
1598 l
|= itoa64_to_int (buf
[18]) << 12;
1599 l
|= itoa64_to_int (buf
[19]) << 18;
1601 digest
[14] = (l
>> 0) & 0xff;
1602 digest
[13] = (l
>> 8) & 0xff;
1603 digest
[12] = (l
>> 16) & 0xff;
1605 l
= itoa64_to_int (buf
[20]) << 0;
1606 l
|= itoa64_to_int (buf
[21]) << 6;
1607 l
|= itoa64_to_int (buf
[22]) << 12;
1608 l
|= itoa64_to_int (buf
[23]) << 18;
1610 digest
[17] = (l
>> 0) & 0xff;
1611 digest
[16] = (l
>> 8) & 0xff;
1612 digest
[15] = (l
>> 16) & 0xff;
1614 l
= itoa64_to_int (buf
[24]) << 0;
1615 l
|= itoa64_to_int (buf
[25]) << 6;
1616 l
|= itoa64_to_int (buf
[26]) << 12;
1617 l
|= itoa64_to_int (buf
[27]) << 18;
1619 digest
[20] = (l
>> 0) & 0xff;
1620 digest
[19] = (l
>> 8) & 0xff;
1621 digest
[18] = (l
>> 16) & 0xff;
1623 l
= itoa64_to_int (buf
[28]) << 0;
1624 l
|= itoa64_to_int (buf
[29]) << 6;
1625 l
|= itoa64_to_int (buf
[30]) << 12;
1626 l
|= itoa64_to_int (buf
[31]) << 18;
1628 digest
[23] = (l
>> 0) & 0xff;
1629 digest
[22] = (l
>> 8) & 0xff;
1630 digest
[21] = (l
>> 16) & 0xff;
1632 l
= itoa64_to_int (buf
[32]) << 0;
1633 l
|= itoa64_to_int (buf
[33]) << 6;
1634 l
|= itoa64_to_int (buf
[34]) << 12;
1635 l
|= itoa64_to_int (buf
[35]) << 18;
1637 digest
[26] = (l
>> 0) & 0xff;
1638 digest
[25] = (l
>> 8) & 0xff;
1639 digest
[24] = (l
>> 16) & 0xff;
1641 l
= itoa64_to_int (buf
[36]) << 0;
1642 l
|= itoa64_to_int (buf
[37]) << 6;
1643 l
|= itoa64_to_int (buf
[38]) << 12;
1644 l
|= itoa64_to_int (buf
[39]) << 18;
1646 digest
[29] = (l
>> 0) & 0xff;
1647 digest
[28] = (l
>> 8) & 0xff;
1648 digest
[27] = (l
>> 16) & 0xff;
1650 l
= itoa64_to_int (buf
[40]) << 0;
1651 l
|= itoa64_to_int (buf
[41]) << 6;
1652 l
|= itoa64_to_int (buf
[42]) << 12;
1653 l
|= itoa64_to_int (buf
[43]) << 18;
1655 digest
[32] = (l
>> 0) & 0xff;
1656 digest
[31] = (l
>> 8) & 0xff;
1657 digest
[30] = (l
>> 16) & 0xff;
1659 l
= itoa64_to_int (buf
[44]) << 0;
1660 l
|= itoa64_to_int (buf
[45]) << 6;
1661 l
|= itoa64_to_int (buf
[46]) << 12;
1662 l
|= itoa64_to_int (buf
[47]) << 18;
1664 digest
[35] = (l
>> 0) & 0xff;
1665 digest
[34] = (l
>> 8) & 0xff;
1666 digest
[33] = (l
>> 16) & 0xff;
1668 l
= itoa64_to_int (buf
[48]) << 0;
1669 l
|= itoa64_to_int (buf
[49]) << 6;
1670 l
|= itoa64_to_int (buf
[50]) << 12;
1671 l
|= itoa64_to_int (buf
[51]) << 18;
1673 digest
[38] = (l
>> 0) & 0xff;
1674 digest
[37] = (l
>> 8) & 0xff;
1675 digest
[36] = (l
>> 16) & 0xff;
1677 l
= itoa64_to_int (buf
[52]) << 0;
1678 l
|= itoa64_to_int (buf
[53]) << 6;
1679 l
|= itoa64_to_int (buf
[54]) << 12;
1680 l
|= itoa64_to_int (buf
[55]) << 18;
1682 digest
[41] = (l
>> 0) & 0xff;
1683 digest
[40] = (l
>> 8) & 0xff;
1684 digest
[39] = (l
>> 16) & 0xff;
1686 l
= itoa64_to_int (buf
[56]) << 0;
1687 l
|= itoa64_to_int (buf
[57]) << 6;
1688 l
|= itoa64_to_int (buf
[58]) << 12;
1689 l
|= itoa64_to_int (buf
[59]) << 18;
1691 digest
[44] = (l
>> 0) & 0xff;
1692 digest
[43] = (l
>> 8) & 0xff;
1693 digest
[42] = (l
>> 16) & 0xff;
1695 l
= itoa64_to_int (buf
[60]) << 0;
1696 l
|= itoa64_to_int (buf
[61]) << 6;
1697 l
|= itoa64_to_int (buf
[62]) << 12;
1698 l
|= itoa64_to_int (buf
[63]) << 18;
1700 digest
[47] = (l
>> 0) & 0xff;
1701 digest
[46] = (l
>> 8) & 0xff;
1702 digest
[45] = (l
>> 16) & 0xff;
1704 l
= itoa64_to_int (buf
[64]) << 0;
1705 l
|= itoa64_to_int (buf
[65]) << 6;
1706 l
|= itoa64_to_int (buf
[66]) << 12;
1707 l
|= itoa64_to_int (buf
[67]) << 18;
1709 digest
[50] = (l
>> 0) & 0xff;
1710 digest
[49] = (l
>> 8) & 0xff;
1711 digest
[48] = (l
>> 16) & 0xff;
1713 l
= itoa64_to_int (buf
[68]) << 0;
1714 l
|= itoa64_to_int (buf
[69]) << 6;
1715 l
|= itoa64_to_int (buf
[70]) << 12;
1716 l
|= itoa64_to_int (buf
[71]) << 18;
1718 digest
[53] = (l
>> 0) & 0xff;
1719 digest
[52] = (l
>> 8) & 0xff;
1720 digest
[51] = (l
>> 16) & 0xff;
1722 l
= itoa64_to_int (buf
[72]) << 0;
1723 l
|= itoa64_to_int (buf
[73]) << 6;
1724 l
|= itoa64_to_int (buf
[74]) << 12;
1725 l
|= itoa64_to_int (buf
[75]) << 18;
1727 digest
[56] = (l
>> 0) & 0xff;
1728 digest
[55] = (l
>> 8) & 0xff;
1729 digest
[54] = (l
>> 16) & 0xff;
1731 l
= itoa64_to_int (buf
[76]) << 0;
1732 l
|= itoa64_to_int (buf
[77]) << 6;
1733 l
|= itoa64_to_int (buf
[78]) << 12;
1734 l
|= itoa64_to_int (buf
[79]) << 18;
1736 digest
[59] = (l
>> 0) & 0xff;
1737 digest
[58] = (l
>> 8) & 0xff;
1738 digest
[57] = (l
>> 16) & 0xff;
1740 l
= itoa64_to_int (buf
[80]) << 0;
1741 l
|= itoa64_to_int (buf
[81]) << 6;
1742 l
|= itoa64_to_int (buf
[82]) << 12;
1743 l
|= itoa64_to_int (buf
[83]) << 18;
1745 digest
[62] = (l
>> 0) & 0xff;
1746 digest
[61] = (l
>> 8) & 0xff;
1747 digest
[60] = (l
>> 16) & 0xff;
1749 l
= itoa64_to_int (buf
[84]) << 0;
1750 l
|= itoa64_to_int (buf
[85]) << 6;
1752 digest
[63] = (l
>> 16) & 0xff;
1755 void sha512aix_encode (unsigned char digest
[64], unsigned char buf
[86])
1759 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1761 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1762 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1763 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1764 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1766 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1768 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1773 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1775 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[11] = int_to_itoa64 (l
& 0x3f);
1780 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1782 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[15] = int_to_itoa64 (l
& 0x3f);
1787 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1789 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[19] = int_to_itoa64 (l
& 0x3f);
1794 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1796 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[23] = int_to_itoa64 (l
& 0x3f);
1801 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1803 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[27] = int_to_itoa64 (l
& 0x3f);
1808 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1810 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[31] = int_to_itoa64 (l
& 0x3f);
1815 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1817 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[35] = int_to_itoa64 (l
& 0x3f);
1822 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1824 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[39] = int_to_itoa64 (l
& 0x3f);
1829 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1831 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[43] = int_to_itoa64 (l
& 0x3f);
1836 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1838 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[47] = int_to_itoa64 (l
& 0x3f);
1843 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1845 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[51] = int_to_itoa64 (l
& 0x3f);
1850 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1852 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[55] = int_to_itoa64 (l
& 0x3f);
1857 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1859 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[59] = int_to_itoa64 (l
& 0x3f);
1864 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1866 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[63] = int_to_itoa64 (l
& 0x3f);
1871 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1873 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[67] = int_to_itoa64 (l
& 0x3f);
1878 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1880 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[71] = int_to_itoa64 (l
& 0x3f);
1885 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1887 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[75] = int_to_itoa64 (l
& 0x3f);
1892 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1894 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[79] = int_to_itoa64 (l
& 0x3f);
1899 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1901 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[83] = int_to_itoa64 (l
& 0x3f);
1906 l
= 0 | 0 | (digest
[63] << 16);
1908 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 void sha256crypt_decode (unsigned char digest
[32], unsigned char buf
[43])
1916 l
= itoa64_to_int (buf
[ 0]) << 0;
1917 l
|= itoa64_to_int (buf
[ 1]) << 6;
1918 l
|= itoa64_to_int (buf
[ 2]) << 12;
1919 l
|= itoa64_to_int (buf
[ 3]) << 18;
1921 digest
[ 0] = (l
>> 16) & 0xff;
1922 digest
[10] = (l
>> 8) & 0xff;
1923 digest
[20] = (l
>> 0) & 0xff;
1925 l
= itoa64_to_int (buf
[ 4]) << 0;
1926 l
|= itoa64_to_int (buf
[ 5]) << 6;
1927 l
|= itoa64_to_int (buf
[ 6]) << 12;
1928 l
|= itoa64_to_int (buf
[ 7]) << 18;
1930 digest
[21] = (l
>> 16) & 0xff;
1931 digest
[ 1] = (l
>> 8) & 0xff;
1932 digest
[11] = (l
>> 0) & 0xff;
1934 l
= itoa64_to_int (buf
[ 8]) << 0;
1935 l
|= itoa64_to_int (buf
[ 9]) << 6;
1936 l
|= itoa64_to_int (buf
[10]) << 12;
1937 l
|= itoa64_to_int (buf
[11]) << 18;
1939 digest
[12] = (l
>> 16) & 0xff;
1940 digest
[22] = (l
>> 8) & 0xff;
1941 digest
[ 2] = (l
>> 0) & 0xff;
1943 l
= itoa64_to_int (buf
[12]) << 0;
1944 l
|= itoa64_to_int (buf
[13]) << 6;
1945 l
|= itoa64_to_int (buf
[14]) << 12;
1946 l
|= itoa64_to_int (buf
[15]) << 18;
1948 digest
[ 3] = (l
>> 16) & 0xff;
1949 digest
[13] = (l
>> 8) & 0xff;
1950 digest
[23] = (l
>> 0) & 0xff;
1952 l
= itoa64_to_int (buf
[16]) << 0;
1953 l
|= itoa64_to_int (buf
[17]) << 6;
1954 l
|= itoa64_to_int (buf
[18]) << 12;
1955 l
|= itoa64_to_int (buf
[19]) << 18;
1957 digest
[24] = (l
>> 16) & 0xff;
1958 digest
[ 4] = (l
>> 8) & 0xff;
1959 digest
[14] = (l
>> 0) & 0xff;
1961 l
= itoa64_to_int (buf
[20]) << 0;
1962 l
|= itoa64_to_int (buf
[21]) << 6;
1963 l
|= itoa64_to_int (buf
[22]) << 12;
1964 l
|= itoa64_to_int (buf
[23]) << 18;
1966 digest
[15] = (l
>> 16) & 0xff;
1967 digest
[25] = (l
>> 8) & 0xff;
1968 digest
[ 5] = (l
>> 0) & 0xff;
1970 l
= itoa64_to_int (buf
[24]) << 0;
1971 l
|= itoa64_to_int (buf
[25]) << 6;
1972 l
|= itoa64_to_int (buf
[26]) << 12;
1973 l
|= itoa64_to_int (buf
[27]) << 18;
1975 digest
[ 6] = (l
>> 16) & 0xff;
1976 digest
[16] = (l
>> 8) & 0xff;
1977 digest
[26] = (l
>> 0) & 0xff;
1979 l
= itoa64_to_int (buf
[28]) << 0;
1980 l
|= itoa64_to_int (buf
[29]) << 6;
1981 l
|= itoa64_to_int (buf
[30]) << 12;
1982 l
|= itoa64_to_int (buf
[31]) << 18;
1984 digest
[27] = (l
>> 16) & 0xff;
1985 digest
[ 7] = (l
>> 8) & 0xff;
1986 digest
[17] = (l
>> 0) & 0xff;
1988 l
= itoa64_to_int (buf
[32]) << 0;
1989 l
|= itoa64_to_int (buf
[33]) << 6;
1990 l
|= itoa64_to_int (buf
[34]) << 12;
1991 l
|= itoa64_to_int (buf
[35]) << 18;
1993 digest
[18] = (l
>> 16) & 0xff;
1994 digest
[28] = (l
>> 8) & 0xff;
1995 digest
[ 8] = (l
>> 0) & 0xff;
1997 l
= itoa64_to_int (buf
[36]) << 0;
1998 l
|= itoa64_to_int (buf
[37]) << 6;
1999 l
|= itoa64_to_int (buf
[38]) << 12;
2000 l
|= itoa64_to_int (buf
[39]) << 18;
2002 digest
[ 9] = (l
>> 16) & 0xff;
2003 digest
[19] = (l
>> 8) & 0xff;
2004 digest
[29] = (l
>> 0) & 0xff;
2006 l
= itoa64_to_int (buf
[40]) << 0;
2007 l
|= itoa64_to_int (buf
[41]) << 6;
2008 l
|= itoa64_to_int (buf
[42]) << 12;
2010 digest
[31] = (l
>> 8) & 0xff;
2011 digest
[30] = (l
>> 0) & 0xff;
2014 void sha256crypt_encode (unsigned char digest
[32], unsigned char buf
[43])
2018 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2020 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2021 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2022 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2027 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2034 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2041 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2048 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2055 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2062 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2069 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2076 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2083 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2090 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[42] = int_to_itoa64 (l
& 0x3f);
2095 void drupal7_decode (unsigned char digest
[64], unsigned char buf
[44])
2099 l
= itoa64_to_int (buf
[ 0]) << 0;
2100 l
|= itoa64_to_int (buf
[ 1]) << 6;
2101 l
|= itoa64_to_int (buf
[ 2]) << 12;
2102 l
|= itoa64_to_int (buf
[ 3]) << 18;
2104 digest
[ 0] = (l
>> 0) & 0xff;
2105 digest
[ 1] = (l
>> 8) & 0xff;
2106 digest
[ 2] = (l
>> 16) & 0xff;
2108 l
= itoa64_to_int (buf
[ 4]) << 0;
2109 l
|= itoa64_to_int (buf
[ 5]) << 6;
2110 l
|= itoa64_to_int (buf
[ 6]) << 12;
2111 l
|= itoa64_to_int (buf
[ 7]) << 18;
2113 digest
[ 3] = (l
>> 0) & 0xff;
2114 digest
[ 4] = (l
>> 8) & 0xff;
2115 digest
[ 5] = (l
>> 16) & 0xff;
2117 l
= itoa64_to_int (buf
[ 8]) << 0;
2118 l
|= itoa64_to_int (buf
[ 9]) << 6;
2119 l
|= itoa64_to_int (buf
[10]) << 12;
2120 l
|= itoa64_to_int (buf
[11]) << 18;
2122 digest
[ 6] = (l
>> 0) & 0xff;
2123 digest
[ 7] = (l
>> 8) & 0xff;
2124 digest
[ 8] = (l
>> 16) & 0xff;
2126 l
= itoa64_to_int (buf
[12]) << 0;
2127 l
|= itoa64_to_int (buf
[13]) << 6;
2128 l
|= itoa64_to_int (buf
[14]) << 12;
2129 l
|= itoa64_to_int (buf
[15]) << 18;
2131 digest
[ 9] = (l
>> 0) & 0xff;
2132 digest
[10] = (l
>> 8) & 0xff;
2133 digest
[11] = (l
>> 16) & 0xff;
2135 l
= itoa64_to_int (buf
[16]) << 0;
2136 l
|= itoa64_to_int (buf
[17]) << 6;
2137 l
|= itoa64_to_int (buf
[18]) << 12;
2138 l
|= itoa64_to_int (buf
[19]) << 18;
2140 digest
[12] = (l
>> 0) & 0xff;
2141 digest
[13] = (l
>> 8) & 0xff;
2142 digest
[14] = (l
>> 16) & 0xff;
2144 l
= itoa64_to_int (buf
[20]) << 0;
2145 l
|= itoa64_to_int (buf
[21]) << 6;
2146 l
|= itoa64_to_int (buf
[22]) << 12;
2147 l
|= itoa64_to_int (buf
[23]) << 18;
2149 digest
[15] = (l
>> 0) & 0xff;
2150 digest
[16] = (l
>> 8) & 0xff;
2151 digest
[17] = (l
>> 16) & 0xff;
2153 l
= itoa64_to_int (buf
[24]) << 0;
2154 l
|= itoa64_to_int (buf
[25]) << 6;
2155 l
|= itoa64_to_int (buf
[26]) << 12;
2156 l
|= itoa64_to_int (buf
[27]) << 18;
2158 digest
[18] = (l
>> 0) & 0xff;
2159 digest
[19] = (l
>> 8) & 0xff;
2160 digest
[20] = (l
>> 16) & 0xff;
2162 l
= itoa64_to_int (buf
[28]) << 0;
2163 l
|= itoa64_to_int (buf
[29]) << 6;
2164 l
|= itoa64_to_int (buf
[30]) << 12;
2165 l
|= itoa64_to_int (buf
[31]) << 18;
2167 digest
[21] = (l
>> 0) & 0xff;
2168 digest
[22] = (l
>> 8) & 0xff;
2169 digest
[23] = (l
>> 16) & 0xff;
2171 l
= itoa64_to_int (buf
[32]) << 0;
2172 l
|= itoa64_to_int (buf
[33]) << 6;
2173 l
|= itoa64_to_int (buf
[34]) << 12;
2174 l
|= itoa64_to_int (buf
[35]) << 18;
2176 digest
[24] = (l
>> 0) & 0xff;
2177 digest
[25] = (l
>> 8) & 0xff;
2178 digest
[26] = (l
>> 16) & 0xff;
2180 l
= itoa64_to_int (buf
[36]) << 0;
2181 l
|= itoa64_to_int (buf
[37]) << 6;
2182 l
|= itoa64_to_int (buf
[38]) << 12;
2183 l
|= itoa64_to_int (buf
[39]) << 18;
2185 digest
[27] = (l
>> 0) & 0xff;
2186 digest
[28] = (l
>> 8) & 0xff;
2187 digest
[29] = (l
>> 16) & 0xff;
2189 l
= itoa64_to_int (buf
[40]) << 0;
2190 l
|= itoa64_to_int (buf
[41]) << 6;
2191 l
|= itoa64_to_int (buf
[42]) << 12;
2192 l
|= itoa64_to_int (buf
[43]) << 18;
2194 digest
[30] = (l
>> 0) & 0xff;
2195 digest
[31] = (l
>> 8) & 0xff;
2196 digest
[32] = (l
>> 16) & 0xff;
2231 void drupal7_encode (unsigned char digest
[64], unsigned char buf
[43])
2235 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2237 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2238 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2239 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2240 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2242 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2244 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2249 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2251 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[11] = int_to_itoa64 (l
& 0x3f);
2256 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2258 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[15] = int_to_itoa64 (l
& 0x3f);
2263 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2265 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[19] = int_to_itoa64 (l
& 0x3f);
2270 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2272 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[23] = int_to_itoa64 (l
& 0x3f);
2277 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2279 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[27] = int_to_itoa64 (l
& 0x3f);
2284 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2286 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[31] = int_to_itoa64 (l
& 0x3f);
2291 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2293 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[35] = int_to_itoa64 (l
& 0x3f);
2298 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2300 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[39] = int_to_itoa64 (l
& 0x3f);
2305 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2307 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 //buf[43] = int_to_itoa64 (l & 0x3f);
2318 static struct termio savemodes
;
2319 static int havemodes
= 0;
2323 struct termio modmodes
;
2325 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2329 modmodes
= savemodes
;
2330 modmodes
.c_lflag
&= ~ICANON
;
2331 modmodes
.c_cc
[VMIN
] = 1;
2332 modmodes
.c_cc
[VTIME
] = 0;
2334 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2343 FD_SET (fileno (stdin
), &rfds
);
2350 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2352 if (retval
== 0) return 0;
2353 if (retval
== -1) return -1;
2360 if (!havemodes
) return 0;
2362 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2367 static struct termios savemodes
;
2368 static int havemodes
= 0;
2372 struct termios modmodes
;
2374 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2378 modmodes
= savemodes
;
2379 modmodes
.c_lflag
&= ~ICANON
;
2380 modmodes
.c_cc
[VMIN
] = 1;
2381 modmodes
.c_cc
[VTIME
] = 0;
2383 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2392 FD_SET (fileno (stdin
), &rfds
);
2399 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2401 if (retval
== 0) return 0;
2402 if (retval
== -1) return -1;
2409 if (!havemodes
) return 0;
2411 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2416 static DWORD saveMode
= 0;
2420 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2422 GetConsoleMode (stdinHandle
, &saveMode
);
2423 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2430 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2432 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2434 if (rc
== WAIT_TIMEOUT
) return 0;
2435 if (rc
== WAIT_ABANDONED
) return -1;
2436 if (rc
== WAIT_FAILED
) return -1;
2438 // The whole ReadConsoleInput () part is a workaround.
2439 // For some unknown reason, maybe a mingw bug, a random signal
2440 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2441 // Then it wants to read with getche () a keyboard input
2442 // which has never been made.
2444 INPUT_RECORD buf
[100];
2448 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2450 FlushConsoleInputBuffer (stdinHandle
);
2452 for (uint i
= 0; i
< num
; i
++)
2454 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2456 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2458 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2460 return KeyEvent
.uChar
.AsciiChar
;
2468 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2470 SetConsoleMode (stdinHandle
, saveMode
);
2480 #define MSG_ENOMEM "Insufficient memory available"
2482 void *mycalloc (size_t nmemb
, size_t size
)
2484 void *p
= calloc (nmemb
, size
);
2488 log_error ("ERROR: %s", MSG_ENOMEM
);
2496 void *mymalloc (size_t size
)
2498 void *p
= malloc (size
);
2502 log_error ("ERROR: %s", MSG_ENOMEM
);
2507 memset (p
, 0, size
);
2512 void myfree (void *ptr
)
2514 if (ptr
== NULL
) return;
2519 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2521 void *p
= realloc (ptr
, oldsz
+ add
);
2525 log_error ("ERROR: %s", MSG_ENOMEM
);
2530 memset ((char *) p
+ oldsz
, 0, add
);
2535 char *mystrdup (const char *s
)
2537 const size_t len
= strlen (s
);
2539 char *b
= (char *) mymalloc (len
+ 1);
2546 FILE *logfile_open (char *logfile
)
2548 FILE *fp
= fopen (logfile
, "ab");
2558 void logfile_close (FILE *fp
)
2560 if (fp
== stdout
) return;
2565 void logfile_append (const char *fmt
, ...)
2567 if (data
.logfile_disable
== 1) return;
2569 FILE *fp
= logfile_open (data
.logfile
);
2575 vfprintf (fp
, fmt
, ap
);
2586 int logfile_generate_id ()
2588 const int n
= rand ();
2597 char *logfile_generate_topid ()
2599 const int id
= logfile_generate_id ();
2601 char *topid
= (char *) mymalloc (1 + 16 + 1);
2603 sprintf (topid
, "TOP%08x", id
);
2608 char *logfile_generate_subid ()
2610 const int id
= logfile_generate_id ();
2612 char *subid
= (char *) mymalloc (1 + 16 + 1);
2614 sprintf (subid
, "SUB%08x", id
);
2626 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2628 FlushFileBuffers (h
);
2637 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2641 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2645 log_info ("WARN: No NvAPI adapters found");
2655 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2659 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2661 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2663 //can be used to determine if the device by index matches the cuda device by index
2664 //char name[100]; memset (name, 0, sizeof (name));
2665 //hc_NVML_nvmlDeviceGetName (data.hm_dll, nvGPUHandle[i], name, sizeof (name) - 1);
2672 log_info ("WARN: No NVML adapters found");
2681 void hm_close (HM_LIB hm_dll
)
2687 FreeLibrary (hm_dll
);
2694 HM_LIB hm_dll
= NULL
;
2696 if (data
.vendor_id
== VENDOR_ID_AMD
)
2699 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2702 hm_dll
= LoadLibrary ("atiadlxx.dll");
2706 hm_dll
= LoadLibrary ("atiadlxy.dll");
2713 if (data
.vendor_id
== VENDOR_ID_NV
)
2715 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2722 int get_adapters_num_amd (HM_LIB hm_dll
, int *iNumberAdapters
)
2724 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll
, iNumberAdapters
) != ADL_OK
) return -1;
2726 if (iNumberAdapters
== 0)
2728 log_info ("WARN: No ADL adapters found.");
2737 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2739 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2740 ADLODParameters lpOdParameters;
2742 lpOdParameters.iSize = sizeof (ADLODParameters);
2743 size_t plevels_size = 0;
2745 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2747 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2748 __func__, iAdapterIndex,
2749 lpOdParameters.iNumberOfPerformanceLevels,
2750 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2751 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2753 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2755 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2757 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2759 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2761 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2762 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2763 __func__, iAdapterIndex, j,
2764 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2766 myfree (lpOdPerformanceLevels);
2772 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll
, int iNumberAdapters
)
2774 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2776 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2778 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2780 return lpAdapterInfo
;
2785 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2788 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2792 for (uint i = 0; i < num_adl_adapters; i++)
2794 int opencl_bus_num = hm_device[i].busid;
2795 int opencl_dev_num = hm_device[i].devid;
2797 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2805 if (idx >= DEVICES_MAX) return -1;
2810 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2812 for (uint i = 0; i < opencl_num_devices; i++)
2814 cl_device_topology_amd device_topology;
2816 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2818 hm_device[i].busid = device_topology.pcie.bus;
2819 hm_device[i].devid = device_topology.pcie.device;
2824 void hm_sort_adl_adapters_by_busid_devid (uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2826 // basically bubble sort
2828 for (int i
= 0; i
< num_adl_adapters
; i
++)
2830 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2832 // get info of adapter [x]
2834 uint32_t adapter_index_x
= valid_adl_device_list
[j
];
2835 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2837 uint32_t bus_num_x
= info_x
.iBusNumber
;
2838 uint32_t dev_num_x
= info_x
.iDeviceNumber
;
2840 // get info of adapter [y]
2842 uint32_t adapter_index_y
= valid_adl_device_list
[j
+ 1];
2843 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2845 uint32_t bus_num_y
= info_y
.iBusNumber
;
2846 uint32_t dev_num_y
= info_y
.iDeviceNumber
;
2850 if (bus_num_y
< bus_num_x
)
2854 else if (bus_num_y
== bus_num_x
)
2856 if (dev_num_y
< dev_num_x
)
2864 uint32_t temp
= valid_adl_device_list
[j
+ 1];
2866 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2867 valid_adl_device_list
[j
+ 0] = temp
;
2873 uint32_t *hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2875 *num_adl_adapters
= 0;
2877 uint32_t *adl_adapters
= NULL
;
2879 int *bus_numbers
= NULL
;
2880 int *device_numbers
= NULL
;
2882 for (int i
= 0; i
< iNumberAdapters
; i
++)
2884 AdapterInfo info
= lpAdapterInfo
[i
];
2886 if ((info
.strUDID
== NULL
) || (strlen (info
.strUDID
) < 1)) continue;
2889 if (info
.iVendorID
!= 1002) continue;
2891 if (info
.iVendorID
!= 0x1002) continue;
2894 if (info
.iBusNumber
< 0) continue;
2895 if (info
.iDeviceNumber
< 0) continue;
2899 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2901 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2908 if (found
) continue;
2910 // add it to the list
2912 adl_adapters
= (uint32_t *) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2914 adl_adapters
[*num_adl_adapters
] = i
;
2916 // rest is just bookkeeping
2918 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2921 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2922 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2924 (*num_adl_adapters
)++;
2927 myfree (bus_numbers
);
2928 myfree (device_numbers
);
2930 // sort the list by increasing bus id, device id number
2932 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2934 return adl_adapters
;
2937 int hm_check_fanspeed_control (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2939 // loop through all valid devices
2941 for (int i
= 0; i
< num_adl_adapters
; i
++)
2943 uint32_t adapter_index
= valid_adl_device_list
[i
];
2947 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2949 // unfortunately this doesn't work since bus id and dev id are not unique
2950 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2951 // if (opencl_device_index == -1) continue;
2953 int opencl_device_index
= i
;
2955 // if (hm_show_performance_level (hm_dll, info.iAdapterIndex) != 0) return -1;
2957 // get fanspeed info
2959 if (hm_device
[opencl_device_index
].od_version
== 5)
2961 ADLFanSpeedInfo FanSpeedInfo
;
2963 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2965 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2967 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2969 // check read and write capability in fanspeedinfo
2971 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2972 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2974 hm_device
[opencl_device_index
].fan_supported
= 1;
2978 hm_device
[opencl_device_index
].fan_supported
= 0;
2981 else // od_version == 6
2983 ADLOD6FanSpeedInfo faninfo
;
2985 memset (&faninfo
, 0, sizeof (faninfo
));
2987 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2989 // check read capability in fanspeedinfo
2991 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2993 hm_device
[opencl_device_index
].fan_supported
= 1;
2997 hm_device
[opencl_device_index
].fan_supported
= 0;
3005 int hm_get_overdrive_version (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3007 for (int i
= 0; i
< num_adl_adapters
; i
++)
3009 uint32_t adapter_index
= valid_adl_device_list
[i
];
3013 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3015 // get overdrive version
3017 int od_supported
= 0;
3021 if (hc_ADL_Overdrive_Caps (hm_dll
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3023 // store the overdrive version in hm_device
3025 // unfortunately this doesn't work since bus id and dev id are not unique
3026 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3027 // if (opencl_device_index == -1) continue;
3029 int opencl_device_index
= i
;
3031 hm_device
[opencl_device_index
].od_version
= od_version
;
3037 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3039 for (int i
= 0; i
< num_adl_adapters
; i
++)
3041 uint32_t adapter_index
= valid_adl_device_list
[i
];
3045 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3047 // store the iAdapterIndex in hm_device
3049 // unfortunately this doesn't work since bus id and dev id are not unique
3050 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3051 // if (opencl_device_index == -1) continue;
3053 int opencl_device_index
= i
;
3055 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3058 return num_adl_adapters
;
3061 int hm_get_temperature_with_device_id (const uint device_id
)
3063 if (data
.vendor_id
== VENDOR_ID_AMD
)
3067 if (data
.hm_device
[device_id
].od_version
== 5)
3069 ADLTemperature Temperature
;
3071 Temperature
.iSize
= sizeof (ADLTemperature
);
3073 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3075 return Temperature
.iTemperature
/ 1000;
3077 else if (data
.hm_device
[device_id
].od_version
== 6)
3079 int Temperature
= 0;
3081 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3083 return Temperature
/ 1000;
3088 if (data
.vendor_id
== VENDOR_ID_NV
)
3091 int temperature
= 0;
3093 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3099 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3101 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3102 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3103 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3104 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3106 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3108 return pThermalSettings
.sensor
[0].currentTemp
;
3115 int hm_get_fanspeed_with_device_id (const uint device_id
)
3117 if (data
.hm_device
[device_id
].fan_supported
== 1)
3119 if (data
.vendor_id
== VENDOR_ID_AMD
)
3123 if (data
.hm_device
[device_id
].od_version
== 5)
3125 ADLFanSpeedValue lpFanSpeedValue
;
3127 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3129 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3130 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3131 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3133 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3135 return lpFanSpeedValue
.iFanSpeed
;
3137 else // od_version == 6
3139 ADLOD6FanSpeedInfo faninfo
;
3141 memset (&faninfo
, 0, sizeof (faninfo
));
3143 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3145 return faninfo
.iFanSpeedPercent
;
3150 if (data
.vendor_id
== VENDOR_ID_NV
)
3155 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3163 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3173 int hm_get_utilization_with_device_id (const uint device_id
)
3175 if (data
.vendor_id
== VENDOR_ID_AMD
)
3179 ADLPMActivity PMActivity
;
3181 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3183 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3185 return PMActivity
.iActivityPercent
;
3189 if (data
.vendor_id
== VENDOR_ID_NV
)
3192 nvmlUtilization_t utilization
;
3194 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3196 return utilization
.gpu
;
3200 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3202 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3204 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3206 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3213 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3215 if (data
.hm_device
[device_id
].fan_supported
== 1)
3219 if (data
.hm_device
[device_id
].od_version
== 5)
3221 ADLFanSpeedValue lpFanSpeedValue
;
3223 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3225 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3226 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3227 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3228 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3230 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3234 else // od_version == 6
3236 ADLOD6FanSpeedValue fan_speed_value
;
3238 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3240 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3241 fan_speed_value
.iFanSpeed
= fanspeed
;
3243 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3257 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3259 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3261 if (css_cnt
> SP_PW_MAX
)
3263 log_error ("ERROR: mask length is too long");
3268 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3270 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3272 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3273 uint cs_len
= css
[css_pos
].cs_len
;
3275 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3277 uint c
= cs_buf
[cs_pos
] & 0xff;
3284 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3286 cs_t
*cs
= &css
[css_cnt
];
3288 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3290 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3292 memset (css_uniq
, 0, css_uniq_sz
);
3296 for (i
= 0; i
< cs
->cs_len
; i
++)
3298 const uint u
= cs
->cs_buf
[i
];
3303 for (i
= 0; i
< in_len
; i
++)
3305 uint u
= in_buf
[i
] & 0xff;
3307 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3309 if (css_uniq
[u
] == 1) continue;
3313 cs
->cs_buf
[cs
->cs_len
] = u
;
3321 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3325 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3327 uint p0
= in_buf
[in_pos
] & 0xff;
3329 if (interpret
== 1 && p0
== '?')
3333 if (in_pos
== in_len
) break;
3335 uint p1
= in_buf
[in_pos
] & 0xff;
3339 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3341 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3343 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3345 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3347 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3349 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3351 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3352 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3354 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3355 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3357 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3358 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3360 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3361 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3363 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3365 default: log_error ("Syntax error: %s", in_buf
);
3371 if (data
.hex_charset
)
3375 if (in_pos
== in_len
)
3377 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3382 uint p1
= in_buf
[in_pos
] & 0xff;
3384 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3386 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3393 chr
= hex_convert (p1
) << 0;
3394 chr
|= hex_convert (p0
) << 4;
3396 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3402 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3408 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3412 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3414 sum
*= css
[css_pos
].cs_len
;
3420 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3422 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3427 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3429 char p0
= mask_buf
[mask_pos
];
3435 if (mask_pos
== mask_len
) break;
3437 char p1
= mask_buf
[mask_pos
];
3443 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3445 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3447 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3449 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3451 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3453 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3455 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3456 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3458 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3459 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3461 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3462 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3464 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3465 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3467 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3469 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3475 if (data
.hex_charset
)
3479 // if there is no 2nd hex character, show an error:
3481 if (mask_pos
== mask_len
)
3483 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3488 char p1
= mask_buf
[mask_pos
];
3490 // if they are not valid hex character, show an error:
3492 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3494 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3501 chr
|= hex_convert (p1
) << 0;
3502 chr
|= hex_convert (p0
) << 4;
3504 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3517 log_error ("ERROR: invalid mask length (0)");
3527 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3529 for (int i
= 0; i
< css_cnt
; i
++)
3531 uint len
= css
[i
].cs_len
;
3532 uint64_t next
= val
/ len
;
3533 uint pos
= val
% len
;
3534 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3539 void mp_cut_at (char *mask
, uint max
)
3543 uint mask_len
= strlen (mask
);
3545 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3547 if (mask
[i
] == '?') i
++;
3553 void mp_setup_sys (cs_t
*mp_sys
)
3557 uint donec
[CHARSIZ
];
3559 memset (donec
, 0, sizeof (donec
));
3561 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3562 mp_sys
[0].cs_buf
[pos
++] = chr
;
3563 mp_sys
[0].cs_len
= pos
; }
3565 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3566 mp_sys
[1].cs_buf
[pos
++] = chr
;
3567 mp_sys
[1].cs_len
= pos
; }
3569 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3570 mp_sys
[2].cs_buf
[pos
++] = chr
;
3571 mp_sys
[2].cs_len
= pos
; }
3573 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3574 mp_sys
[3].cs_buf
[pos
++] = chr
;
3575 mp_sys
[3].cs_len
= pos
; }
3577 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3578 mp_sys
[4].cs_len
= pos
; }
3580 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3581 mp_sys
[5].cs_len
= pos
; }
3584 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3586 FILE *fp
= fopen (buf
, "rb");
3588 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3590 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3596 memset (mp_file
, 0, sizeof (mp_file
));
3598 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3602 len
= in_superchop (mp_file
);
3606 log_info ("WARNING: charset file corrupted");
3608 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3612 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3617 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3619 mp_usr
[index
].cs_len
= 0;
3621 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3624 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3626 char *new_mask_buf
= (char *) mymalloc (256);
3632 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3634 if (css_pos
== len
) break;
3636 char p0
= mask_buf
[mask_pos
];
3638 new_mask_buf
[mask_pos
] = p0
;
3644 if (mask_pos
== mask_len
) break;
3646 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3650 if (data
.hex_charset
)
3654 if (mask_pos
== mask_len
)
3656 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3661 char p1
= mask_buf
[mask_pos
];
3663 // if they are not valid hex character, show an error:
3665 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3667 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3672 new_mask_buf
[mask_pos
] = p1
;
3677 if (css_pos
== len
) return (new_mask_buf
);
3679 myfree (new_mask_buf
);
3688 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3694 for (i
= start
; i
< stop
; i
++)
3696 sum
*= root_css_buf
[i
].cs_len
;
3702 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3706 cs_t
*cs
= &root_css_buf
[start
];
3710 for (i
= start
; i
< stop
; i
++)
3712 const uint64_t m
= v
% cs
->cs_len
;
3713 const uint64_t d
= v
/ cs
->cs_len
;
3717 const uint k
= cs
->cs_buf
[m
];
3719 pw_buf
[i
- start
] = (char) k
;
3721 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3725 int sp_comp_val (const void *p1
, const void *p2
)
3727 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3728 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3730 return b2
->val
- b1
->val
;
3733 void sp_setup_tbl (const char *install_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3740 * Initialize hcstats
3743 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3745 uint64_t *root_stats_ptr
= root_stats_buf
;
3747 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3749 for (i
= 0; i
< SP_PW_MAX
; i
++)
3751 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3753 root_stats_ptr
+= CHARSIZ
;
3756 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3758 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3760 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3762 for (i
= 0; i
< SP_PW_MAX
; i
++)
3764 for (j
= 0; j
< CHARSIZ
; j
++)
3766 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3768 markov_stats_ptr
+= CHARSIZ
;
3778 char hcstat_tmp
[256];
3780 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3782 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", install_dir
, SP_HCSTAT
);
3784 hcstat
= hcstat_tmp
;
3787 FILE *fd
= fopen (hcstat
, "rb");
3791 log_error ("%s: %s", hcstat
, strerror (errno
));
3796 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3798 log_error ("%s: Could not load data", hcstat
);
3803 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3805 log_error ("%s: Could not load data", hcstat
);
3813 * Markov modifier of hcstat_table on user request
3818 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3819 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3824 /* Add all stats to first position */
3826 for (i
= 1; i
< SP_PW_MAX
; i
++)
3828 uint64_t *out
= root_stats_buf_by_pos
[0];
3829 uint64_t *in
= root_stats_buf_by_pos
[i
];
3831 for (j
= 0; j
< CHARSIZ
; j
++)
3837 for (i
= 1; i
< SP_PW_MAX
; i
++)
3839 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3840 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3842 for (j
= 0; j
< CHARSIZ
; j
++)
3844 for (k
= 0; k
< CHARSIZ
; k
++)
3851 /* copy them to all pw_positions */
3853 for (i
= 1; i
< SP_PW_MAX
; i
++)
3855 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3858 for (i
= 1; i
< SP_PW_MAX
; i
++)
3860 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3868 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3870 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3872 for (i
= 0; i
< SP_PW_MAX
; i
++)
3874 root_table_buf_by_pos
[i
] = root_table_ptr
;
3876 root_table_ptr
+= CHARSIZ
;
3879 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3881 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3883 for (i
= 0; i
< SP_PW_MAX
; i
++)
3885 for (j
= 0; j
< CHARSIZ
; j
++)
3887 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3889 markov_table_ptr
+= CHARSIZ
;
3894 * Convert hcstat to tables
3897 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3899 uint key
= i
% CHARSIZ
;
3901 root_table_buf
[i
].key
= key
;
3902 root_table_buf
[i
].val
= root_stats_buf
[i
];
3905 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3907 uint key
= i
% CHARSIZ
;
3909 markov_table_buf
[i
].key
= key
;
3910 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3913 myfree (root_stats_buf
);
3914 myfree (markov_stats_buf
);
3920 for (i
= 0; i
< SP_PW_MAX
; i
++)
3922 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3925 for (i
= 0; i
< SP_PW_MAX
; i
++)
3927 for (j
= 0; j
< CHARSIZ
; j
++)
3929 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3934 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3937 * Convert tables to css
3940 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3942 uint pw_pos
= i
/ CHARSIZ
;
3944 cs_t
*cs
= &root_css_buf
[pw_pos
];
3946 if (cs
->cs_len
== threshold
) continue;
3948 uint key
= root_table_buf
[i
].key
;
3950 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3952 cs
->cs_buf
[cs
->cs_len
] = key
;
3958 * Convert table to css
3961 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3963 uint c
= i
/ CHARSIZ
;
3965 cs_t
*cs
= &markov_css_buf
[c
];
3967 if (cs
->cs_len
== threshold
) continue;
3969 uint pw_pos
= c
/ CHARSIZ
;
3971 uint key
= markov_table_buf
[i
].key
;
3973 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3975 cs
->cs_buf
[cs
->cs_len
] = key
;
3981 for (uint i = 0; i < 8; i++)
3983 for (uint j = 0x20; j < 0x80; j++)
3985 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
3987 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
3989 for (uint k = 0; k < 10; k++)
3991 printf (" %u\n", ptr->cs_buf[k]);
3998 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4000 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4002 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4012 for (uint j
= 1; j
< CHARSIZ
; j
++)
4022 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4024 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4026 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4028 out
+= CHARSIZ
* CHARSIZ
;
4029 in
+= CHARSIZ
* CHARSIZ
;
4031 for (uint j
= 0; j
< CHARSIZ
; j
++)
4038 for (uint k
= 1; k
< CHARSIZ
; k
++)
4050 * mixed shared functions
4053 void dump_hex (const char *s
, size_t size
)
4057 for (i
= 0; i
< size
; i
++)
4059 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4065 void usage_mini_print (const char *progname
)
4067 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4070 void usage_big_print (const char *progname
)
4072 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4075 char *get_install_dir (const char *progname
)
4077 char *install_dir
= mystrdup (progname
);
4078 char *last_slash
= NULL
;
4080 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4084 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4090 install_dir
[0] = '.';
4094 return (install_dir
);
4097 char *get_profile_dir (const char *homedir
)
4099 #define DOT_HASHCAT ".hashcat"
4101 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4103 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4108 char *get_session_dir (const char *profile_dir
, const char *session
)
4110 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (session
) + 1);
4112 sprintf (session_dir
, "%s/%s", profile_dir
, session
);
4117 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4121 FILE *fd
= fopen (file
, "rb");
4125 log_error ("%s: %s", file
, strerror (errno
));
4130 #define MAX_KEY_SIZE (1024 * 1024)
4132 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4134 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4138 for (int fpos
= 0; fpos
< nread
; fpos
++)
4140 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4142 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4143 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4144 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4145 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4147 if (kpos
>= 64) kpos
= 0;
4155 void set_cpu_affinity (char *cpu_affinity
)
4158 DWORD_PTR aff_mask
= 0;
4169 char *devices
= strdup (cpu_affinity
);
4171 char *next
= strtok (devices
, ",");
4175 uint cpu_id
= atoi (next
);
4192 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4198 aff_mask
|= 1 << (cpu_id
- 1);
4202 CPU_SET ((cpu_id
- 1), &cpuset
);
4205 } while ((next
= strtok (NULL
, ",")) != NULL
);
4211 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4212 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4216 pthread_t thread
= pthread_self ();
4217 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4221 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4223 char *element
, *end
;
4225 end
= (char *) base
+ nmemb
* size
;
4227 for (element
= (char *) base
; element
< end
; element
+= size
)
4228 if (!compar (element
, key
))
4234 int sort_by_salt (const void *v1
, const void *v2
)
4236 const salt_t
*s1
= (const salt_t
*) v1
;
4237 const salt_t
*s2
= (const salt_t
*) v2
;
4239 const int res1
= s1
->salt_len
- s2
->salt_len
;
4241 if (res1
!= 0) return (res1
);
4243 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4245 if (res2
!= 0) return (res2
);
4253 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4254 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4261 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4262 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4268 int sort_by_salt_buf (const void *v1
, const void *v2
)
4270 const pot_t
*p1
= (const pot_t
*) v1
;
4271 const pot_t
*p2
= (const pot_t
*) v2
;
4273 const hash_t
*h1
= &p1
->hash
;
4274 const hash_t
*h2
= &p2
->hash
;
4276 const salt_t
*s1
= h1
->salt
;
4277 const salt_t
*s2
= h2
->salt
;
4283 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4284 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4290 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4292 const hash_t
*h1
= (const hash_t
*) v1
;
4293 const hash_t
*h2
= (const hash_t
*) v2
;
4295 const salt_t
*s1
= h1
->salt
;
4296 const salt_t
*s2
= h2
->salt
;
4298 // testphase: this should work
4303 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4304 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4307 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4308 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4309 if (s1->salt_len > s2->salt_len) return ( 1);
4310 if (s1->salt_len < s2->salt_len) return (-1);
4312 uint n = s1->salt_len;
4316 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4317 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4324 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4326 const hash_t
*h1
= (const hash_t
*) v1
;
4327 const hash_t
*h2
= (const hash_t
*) v2
;
4329 const salt_t
*s1
= h1
->salt
;
4330 const salt_t
*s2
= h2
->salt
;
4332 // 12 - 2 (since last 2 uints contain the digest)
4337 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4338 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4344 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4346 const hash_t
*h1
= (const hash_t
*) v1
;
4347 const hash_t
*h2
= (const hash_t
*) v2
;
4349 const void *d1
= h1
->digest
;
4350 const void *d2
= h2
->digest
;
4352 return data
.sort_by_digest (d1
, d2
);
4355 int sort_by_hash (const void *v1
, const void *v2
)
4357 const hash_t
*h1
= (const hash_t
*) v1
;
4358 const hash_t
*h2
= (const hash_t
*) v2
;
4362 const salt_t
*s1
= h1
->salt
;
4363 const salt_t
*s2
= h2
->salt
;
4365 int res
= sort_by_salt (s1
, s2
);
4367 if (res
!= 0) return (res
);
4370 const void *d1
= h1
->digest
;
4371 const void *d2
= h2
->digest
;
4373 return data
.sort_by_digest (d1
, d2
);
4376 int sort_by_pot (const void *v1
, const void *v2
)
4378 const pot_t
*p1
= (const pot_t
*) v1
;
4379 const pot_t
*p2
= (const pot_t
*) v2
;
4381 const hash_t
*h1
= &p1
->hash
;
4382 const hash_t
*h2
= &p2
->hash
;
4384 return sort_by_hash (h1
, h2
);
4387 int sort_by_mtime (const void *p1
, const void *p2
)
4389 const char **f1
= (const char **) p1
;
4390 const char **f2
= (const char **) p2
;
4392 struct stat s1
; stat (*f1
, &s1
);
4393 struct stat s2
; stat (*f2
, &s2
);
4395 return s2
.st_mtime
- s1
.st_mtime
;
4398 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4400 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4401 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4403 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4406 int sort_by_gpu_rule (const void *p1
, const void *p2
)
4408 const gpu_rule_t
*r1
= (const gpu_rule_t
*) p1
;
4409 const gpu_rule_t
*r2
= (const gpu_rule_t
*) p2
;
4411 return memcmp (r1
, r2
, sizeof (gpu_rule_t
));
4414 int sort_by_stringptr (const void *p1
, const void *p2
)
4416 const char **s1
= (const char **) p1
;
4417 const char **s2
= (const char **) p2
;
4419 return strcmp (*s1
, *s2
);
4422 int sort_by_dictstat (const void *s1
, const void *s2
)
4424 dictstat_t
*d1
= (dictstat_t
*) s1
;
4425 dictstat_t
*d2
= (dictstat_t
*) s2
;
4428 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4430 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4433 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4436 int sort_by_bitmap (const void *p1
, const void *p2
)
4438 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4439 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4441 return b1
->collisions
- b2
->collisions
;
4444 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4446 const uint32_t *d1
= (const uint32_t *) v1
;
4447 const uint32_t *d2
= (const uint32_t *) v2
;
4453 if (d1
[n
] > d2
[n
]) return ( 1);
4454 if (d1
[n
] < d2
[n
]) return (-1);
4460 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4462 const uint32_t *d1
= (const uint32_t *) v1
;
4463 const uint32_t *d2
= (const uint32_t *) v2
;
4469 if (d1
[n
] > d2
[n
]) return ( 1);
4470 if (d1
[n
] < d2
[n
]) return (-1);
4476 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4478 const uint32_t *d1
= (const uint32_t *) v1
;
4479 const uint32_t *d2
= (const uint32_t *) v2
;
4485 if (d1
[n
] > d2
[n
]) return ( 1);
4486 if (d1
[n
] < d2
[n
]) return (-1);
4492 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4494 const uint32_t *d1
= (const uint32_t *) v1
;
4495 const uint32_t *d2
= (const uint32_t *) v2
;
4501 if (d1
[n
] > d2
[n
]) return ( 1);
4502 if (d1
[n
] < d2
[n
]) return (-1);
4508 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4510 const uint32_t *d1
= (const uint32_t *) v1
;
4511 const uint32_t *d2
= (const uint32_t *) v2
;
4517 if (d1
[n
] > d2
[n
]) return ( 1);
4518 if (d1
[n
] < d2
[n
]) return (-1);
4524 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4526 const uint32_t *d1
= (const uint32_t *) v1
;
4527 const uint32_t *d2
= (const uint32_t *) v2
;
4533 if (d1
[n
] > d2
[n
]) return ( 1);
4534 if (d1
[n
] < d2
[n
]) return (-1);
4540 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4542 const uint32_t *d1
= (const uint32_t *) v1
;
4543 const uint32_t *d2
= (const uint32_t *) v2
;
4549 if (d1
[n
] > d2
[n
]) return ( 1);
4550 if (d1
[n
] < d2
[n
]) return (-1);
4556 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4558 const uint32_t *d1
= (const uint32_t *) v1
;
4559 const uint32_t *d2
= (const uint32_t *) v2
;
4565 if (d1
[n
] > d2
[n
]) return ( 1);
4566 if (d1
[n
] < d2
[n
]) return (-1);
4572 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4574 const uint64_t *d1
= (const uint64_t *) v1
;
4575 const uint64_t *d2
= (const uint64_t *) v2
;
4581 if (d1
[n
] > d2
[n
]) return ( 1);
4582 if (d1
[n
] < d2
[n
]) return (-1);
4588 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4590 const uint64_t *d1
= (const uint64_t *) v1
;
4591 const uint64_t *d2
= (const uint64_t *) v2
;
4597 if (d1
[n
] > d2
[n
]) return ( 1);
4598 if (d1
[n
] < d2
[n
]) return (-1);
4604 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4606 const uint64_t *d1
= (const uint64_t *) v1
;
4607 const uint64_t *d2
= (const uint64_t *) v2
;
4613 if (d1
[n
] > d2
[n
]) return ( 1);
4614 if (d1
[n
] < d2
[n
]) return (-1);
4620 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4622 const uint32_t *d1
= (const uint32_t *) v1
;
4623 const uint32_t *d2
= (const uint32_t *) v2
;
4625 const uint dgst_pos0
= data
.dgst_pos0
;
4626 const uint dgst_pos1
= data
.dgst_pos1
;
4627 const uint dgst_pos2
= data
.dgst_pos2
;
4628 const uint dgst_pos3
= data
.dgst_pos3
;
4630 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4631 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4632 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4633 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4634 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4635 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4636 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4637 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4642 void format_debug (char * debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4644 uint outfile_autohex
= data
.outfile_autohex
;
4646 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4648 FILE *debug_fp
= NULL
;
4650 if (debug_file
!= NULL
)
4652 debug_fp
= fopen (debug_file
, "ab");
4659 if (debug_fp
== NULL
)
4661 log_info ("WARNING: Could not open debug-file for writing");
4665 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4667 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4669 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4672 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4674 if (debug_mode
== 4)
4676 fputc (':', debug_fp
);
4678 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4681 fputc ('\n', debug_fp
);
4683 if (debug_file
!= NULL
) fclose (debug_fp
);
4687 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4689 int needs_hexify
= 0;
4691 if (outfile_autohex
== 1)
4693 for (uint i
= 0; i
< plain_len
; i
++)
4695 if (plain_ptr
[i
] < 0x20)
4702 if (plain_ptr
[i
] > 0x7f)
4711 if (needs_hexify
== 1)
4713 fprintf (fp
, "$HEX[");
4715 for (uint i
= 0; i
< plain_len
; i
++)
4717 fprintf (fp
, "%02x", plain_ptr
[i
]);
4724 fwrite (plain_ptr
, plain_len
, 1, fp
);
4728 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const uint64_t crackpos
, unsigned char *username
, const uint user_len
)
4730 uint outfile_format
= data
.outfile_format
;
4732 char separator
= data
.separator
;
4734 if (outfile_format
& OUTFILE_FMT_HASH
)
4736 fprintf (out_fp
, "%s", out_buf
);
4738 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4740 fputc (separator
, out_fp
);
4743 else if (data
.username
)
4745 if (username
!= NULL
)
4747 for (uint i
= 0; i
< user_len
; i
++)
4749 fprintf (out_fp
, "%c", username
[i
]);
4752 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4754 fputc (separator
, out_fp
);
4759 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4761 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4763 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4765 fputc (separator
, out_fp
);
4769 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4771 for (uint i
= 0; i
< plain_len
; i
++)
4773 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4776 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4778 fputc (separator
, out_fp
);
4782 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4785 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4790 fprintf (out_fp
, "%lu", crackpos
);
4792 fprintf (out_fp
, "%llu", crackpos
);
4797 fputc ('\n', out_fp
);
4800 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4804 pot_key
.hash
.salt
= hashes_buf
->salt
;
4805 pot_key
.hash
.digest
= hashes_buf
->digest
;
4807 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4813 input_buf
[input_len
] = 0;
4816 unsigned char *username
= NULL
;
4821 user_t
*user
= hashes_buf
->hash_info
->user
;
4825 username
= (unsigned char *) (user
->user_name
);
4827 user_len
= user
->user_len
;
4831 // do output the line
4832 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4836 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4837 #define LM_MASKED_PLAIN "[notfound]"
4839 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4845 pot_left_key
.hash
.salt
= hash_left
->salt
;
4846 pot_left_key
.hash
.digest
= hash_left
->digest
;
4848 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4852 uint weak_hash_found
= 0;
4854 pot_t pot_right_key
;
4856 pot_right_key
.hash
.salt
= hash_right
->salt
;
4857 pot_right_key
.hash
.digest
= hash_right
->digest
;
4859 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4861 if (pot_right_ptr
== NULL
)
4863 // special case, if "weak hash"
4865 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4867 weak_hash_found
= 1;
4869 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4871 // in theory this is not needed, but we are paranoia:
4873 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4874 pot_right_ptr
->plain_len
= 0;
4878 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4880 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
4885 // at least one half was found:
4889 input_buf
[input_len
] = 0;
4893 unsigned char *username
= NULL
;
4898 user_t
*user
= hash_left
->hash_info
->user
;
4902 username
= (unsigned char *) (user
->user_name
);
4904 user_len
= user
->user_len
;
4908 // mask the part which was not found
4910 uint left_part_masked
= 0;
4911 uint right_part_masked
= 0;
4913 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4915 if (pot_left_ptr
== NULL
)
4917 left_part_masked
= 1;
4919 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4921 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4923 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4924 pot_left_ptr
->plain_len
= mask_plain_len
;
4927 if (pot_right_ptr
== NULL
)
4929 right_part_masked
= 1;
4931 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4933 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4935 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4936 pot_right_ptr
->plain_len
= mask_plain_len
;
4939 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4943 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4945 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4947 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4949 // do output the line
4951 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4953 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4955 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4956 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4959 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4963 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4965 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4967 if (pot_ptr
== NULL
)
4971 input_buf
[input_len
] = 0;
4973 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
4977 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4983 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
4985 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4989 pot_t pot_right_key
;
4991 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
4993 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4995 uint weak_hash_found
= 0;
4997 if (pot_right_ptr
== NULL
)
4999 // special case, if "weak hash"
5001 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5003 weak_hash_found
= 1;
5005 // we just need that pot_right_ptr is not a NULL pointer
5007 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5011 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5013 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5018 // ... at least one part was not cracked
5022 input_buf
[input_len
] = 0;
5024 // only show the hash part which is still not cracked
5026 uint user_len
= input_len
- 32;
5028 char hash_output
[user_len
+ 33];
5030 memset (hash_output
, 0, sizeof (hash_output
));
5032 memcpy (hash_output
, input_buf
, input_len
);
5034 if (pot_left_ptr
!= NULL
)
5036 // only show right part (because left part was already found)
5038 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5040 hash_output
[user_len
+ 16] = 0;
5043 if (pot_right_ptr
!= NULL
)
5045 // only show left part (because right part was already found)
5047 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5049 hash_output
[user_len
+ 16] = 0;
5052 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5054 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5057 uint
devices_to_devicemask (char *gpu_devices
)
5059 uint gpu_devicemask
= 0;
5063 char *devices
= strdup (gpu_devices
);
5065 char *next
= strtok (devices
, ",");
5069 uint gpu_id
= atoi (next
);
5071 if (gpu_id
< 1 || gpu_id
> 8)
5073 log_error ("ERROR: invalid gpu_id %u specified", gpu_id
);
5078 gpu_devicemask
|= 1 << (gpu_id
- 1);
5080 } while ((next
= strtok (NULL
, ",")) != NULL
);
5085 return gpu_devicemask
;
5088 uint
get_random_num (uint min
, uint max
)
5090 if (min
== max
) return (min
);
5092 return (uint
) ((rand () % (max
- min
)) + min
);
5095 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5097 uint32_t quotient
= dividend
/ divisor
;
5099 if (dividend
% divisor
) quotient
++;
5104 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5106 uint64_t quotient
= dividend
/ divisor
;
5108 if (dividend
% divisor
) quotient
++;
5113 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5115 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5116 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5118 if (tm
->tm_year
- 70)
5120 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5121 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5123 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5125 else if (tm
->tm_yday
)
5127 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5128 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5130 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5132 else if (tm
->tm_hour
)
5134 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5135 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5137 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5139 else if (tm
->tm_min
)
5141 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5142 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5144 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5148 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5150 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5154 void format_speed_display (float val
, char *buf
, size_t len
)
5165 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5176 /* generate output */
5180 snprintf (buf
, len
- 1, "%.0f ", val
);
5184 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5188 void lowercase (char *buf
, int len
)
5190 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5193 void uppercase (char *buf
, int len
)
5195 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5198 int fgetl (FILE *fp
, char *line_buf
)
5204 const int c
= fgetc (fp
);
5206 if (c
== EOF
) break;
5208 line_buf
[line_len
] = (char) c
;
5212 if (line_len
== BUFSIZ
) line_len
--;
5214 if (c
== '\n') break;
5217 if (line_len
== 0) return 0;
5219 if (line_buf
[line_len
- 1] == '\n')
5223 line_buf
[line_len
] = 0;
5226 if (line_len
== 0) return 0;
5228 if (line_buf
[line_len
- 1] == '\r')
5232 line_buf
[line_len
] = 0;
5238 int in_superchop (char *buf
)
5240 int len
= strlen (buf
);
5244 if (buf
[len
- 1] == '\n')
5251 if (buf
[len
- 1] == '\r')
5266 char **scan_directory (const char *path
)
5268 char *tmp_path
= mystrdup (path
);
5270 size_t tmp_path_len
= strlen (tmp_path
);
5272 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5274 tmp_path
[tmp_path_len
- 1] = 0;
5276 tmp_path_len
= strlen (tmp_path
);
5279 char **files
= NULL
;
5285 if ((d
= opendir (tmp_path
)) != NULL
)
5289 while ((de
= readdir (d
)) != NULL
)
5291 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5293 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5295 char *path_file
= (char *) mymalloc (path_size
+ 1);
5297 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5299 path_file
[path_size
] = 0;
5303 if ((d_test
= opendir (path_file
)) != NULL
)
5311 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5315 files
[num_files
- 1] = path_file
;
5321 else if (errno
== ENOTDIR
)
5323 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5327 files
[num_files
- 1] = mystrdup (path
);
5330 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5334 files
[num_files
- 1] = NULL
;
5341 int count_dictionaries (char **dictionary_files
)
5343 if (dictionary_files
== NULL
) return 0;
5347 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5355 char *stroptitype (const uint opti_type
)
5359 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5360 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5361 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5362 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5363 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5364 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5365 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5366 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5367 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5368 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5369 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5370 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5371 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5372 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5378 char *strparser (const uint parser_status
)
5380 switch (parser_status
)
5382 case PARSER_OK
: return ((char *) PA_000
); break;
5383 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5384 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5385 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5386 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5387 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5388 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5389 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5390 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5391 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5392 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5393 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5394 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5395 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5396 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5397 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5398 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5401 return ((char *) PA_255
);
5404 char *strhashtype (const uint hash_mode
)
5408 case 0: return ((char *) HT_00000
); break;
5409 case 10: return ((char *) HT_00010
); break;
5410 case 11: return ((char *) HT_00011
); break;
5411 case 12: return ((char *) HT_00012
); break;
5412 case 20: return ((char *) HT_00020
); break;
5413 case 21: return ((char *) HT_00021
); break;
5414 case 22: return ((char *) HT_00022
); break;
5415 case 23: return ((char *) HT_00023
); break;
5416 case 30: return ((char *) HT_00030
); break;
5417 case 40: return ((char *) HT_00040
); break;
5418 case 50: return ((char *) HT_00050
); break;
5419 case 60: return ((char *) HT_00060
); break;
5420 case 100: return ((char *) HT_00100
); break;
5421 case 101: return ((char *) HT_00101
); break;
5422 case 110: return ((char *) HT_00110
); break;
5423 case 111: return ((char *) HT_00111
); break;
5424 case 112: return ((char *) HT_00112
); break;
5425 case 120: return ((char *) HT_00120
); break;
5426 case 121: return ((char *) HT_00121
); break;
5427 case 122: return ((char *) HT_00122
); break;
5428 case 124: return ((char *) HT_00124
); break;
5429 case 130: return ((char *) HT_00130
); break;
5430 case 131: return ((char *) HT_00131
); break;
5431 case 132: return ((char *) HT_00132
); break;
5432 case 133: return ((char *) HT_00133
); break;
5433 case 140: return ((char *) HT_00140
); break;
5434 case 141: return ((char *) HT_00141
); break;
5435 case 150: return ((char *) HT_00150
); break;
5436 case 160: return ((char *) HT_00160
); break;
5437 case 190: return ((char *) HT_00190
); break;
5438 case 200: return ((char *) HT_00200
); break;
5439 case 300: return ((char *) HT_00300
); break;
5440 case 400: return ((char *) HT_00400
); break;
5441 case 500: return ((char *) HT_00500
); break;
5442 case 501: return ((char *) HT_00501
); break;
5443 case 900: return ((char *) HT_00900
); break;
5444 case 910: return ((char *) HT_00910
); break;
5445 case 1000: return ((char *) HT_01000
); break;
5446 case 1100: return ((char *) HT_01100
); break;
5447 case 1400: return ((char *) HT_01400
); break;
5448 case 1410: return ((char *) HT_01410
); break;
5449 case 1420: return ((char *) HT_01420
); break;
5450 case 1421: return ((char *) HT_01421
); break;
5451 case 1430: return ((char *) HT_01430
); break;
5452 case 1440: return ((char *) HT_01440
); break;
5453 case 1441: return ((char *) HT_01441
); break;
5454 case 1450: return ((char *) HT_01450
); break;
5455 case 1460: return ((char *) HT_01460
); break;
5456 case 1500: return ((char *) HT_01500
); break;
5457 case 1600: return ((char *) HT_01600
); break;
5458 case 1700: return ((char *) HT_01700
); break;
5459 case 1710: return ((char *) HT_01710
); break;
5460 case 1711: return ((char *) HT_01711
); break;
5461 case 1720: return ((char *) HT_01720
); break;
5462 case 1722: return ((char *) HT_01722
); break;
5463 case 1730: return ((char *) HT_01730
); break;
5464 case 1731: return ((char *) HT_01731
); break;
5465 case 1740: return ((char *) HT_01740
); break;
5466 case 1750: return ((char *) HT_01750
); break;
5467 case 1760: return ((char *) HT_01760
); break;
5468 case 1800: return ((char *) HT_01800
); break;
5469 case 2100: return ((char *) HT_02100
); break;
5470 case 2400: return ((char *) HT_02400
); break;
5471 case 2410: return ((char *) HT_02410
); break;
5472 case 2500: return ((char *) HT_02500
); break;
5473 case 2600: return ((char *) HT_02600
); break;
5474 case 2611: return ((char *) HT_02611
); break;
5475 case 2612: return ((char *) HT_02612
); break;
5476 case 2711: return ((char *) HT_02711
); break;
5477 case 2811: return ((char *) HT_02811
); break;
5478 case 3000: return ((char *) HT_03000
); break;
5479 case 3100: return ((char *) HT_03100
); break;
5480 case 3200: return ((char *) HT_03200
); break;
5481 case 3710: return ((char *) HT_03710
); break;
5482 case 3711: return ((char *) HT_03711
); break;
5483 case 3800: return ((char *) HT_03800
); break;
5484 case 4300: return ((char *) HT_04300
); break;
5485 case 4400: return ((char *) HT_04400
); break;
5486 case 4500: return ((char *) HT_04500
); break;
5487 case 4700: return ((char *) HT_04700
); break;
5488 case 4800: return ((char *) HT_04800
); break;
5489 case 4900: return ((char *) HT_04900
); break;
5490 case 5000: return ((char *) HT_05000
); break;
5491 case 5100: return ((char *) HT_05100
); break;
5492 case 5200: return ((char *) HT_05200
); break;
5493 case 5300: return ((char *) HT_05300
); break;
5494 case 5400: return ((char *) HT_05400
); break;
5495 case 5500: return ((char *) HT_05500
); break;
5496 case 5600: return ((char *) HT_05600
); break;
5497 case 5700: return ((char *) HT_05700
); break;
5498 case 5800: return ((char *) HT_05800
); break;
5499 case 6000: return ((char *) HT_06000
); break;
5500 case 6100: return ((char *) HT_06100
); break;
5501 case 6211: return ((char *) HT_06211
); break;
5502 case 6212: return ((char *) HT_06212
); break;
5503 case 6213: return ((char *) HT_06213
); break;
5504 case 6221: return ((char *) HT_06221
); break;
5505 case 6222: return ((char *) HT_06222
); break;
5506 case 6223: return ((char *) HT_06223
); break;
5507 case 6231: return ((char *) HT_06231
); break;
5508 case 6232: return ((char *) HT_06232
); break;
5509 case 6233: return ((char *) HT_06233
); break;
5510 case 6241: return ((char *) HT_06241
); break;
5511 case 6242: return ((char *) HT_06242
); break;
5512 case 6243: return ((char *) HT_06243
); break;
5513 case 6300: return ((char *) HT_06300
); break;
5514 case 6400: return ((char *) HT_06400
); break;
5515 case 6500: return ((char *) HT_06500
); break;
5516 case 6600: return ((char *) HT_06600
); break;
5517 case 6700: return ((char *) HT_06700
); break;
5518 case 6800: return ((char *) HT_06800
); break;
5519 case 6900: return ((char *) HT_06900
); break;
5520 case 7100: return ((char *) HT_07100
); break;
5521 case 7200: return ((char *) HT_07200
); break;
5522 case 7300: return ((char *) HT_07300
); break;
5523 case 7400: return ((char *) HT_07400
); break;
5524 case 7500: return ((char *) HT_07500
); break;
5525 case 7600: return ((char *) HT_07600
); break;
5526 case 7700: return ((char *) HT_07700
); break;
5527 case 7800: return ((char *) HT_07800
); break;
5528 case 7900: return ((char *) HT_07900
); break;
5529 case 8000: return ((char *) HT_08000
); break;
5530 case 8100: return ((char *) HT_08100
); break;
5531 case 8200: return ((char *) HT_08200
); break;
5532 case 8300: return ((char *) HT_08300
); break;
5533 case 8400: return ((char *) HT_08400
); break;
5534 case 8500: return ((char *) HT_08500
); break;
5535 case 8600: return ((char *) HT_08600
); break;
5536 case 8700: return ((char *) HT_08700
); break;
5537 case 8800: return ((char *) HT_08800
); break;
5538 case 8900: return ((char *) HT_08900
); break;
5539 case 9000: return ((char *) HT_09000
); break;
5540 case 9100: return ((char *) HT_09100
); break;
5541 case 9200: return ((char *) HT_09200
); break;
5542 case 9300: return ((char *) HT_09300
); break;
5543 case 9400: return ((char *) HT_09400
); break;
5544 case 9500: return ((char *) HT_09500
); break;
5545 case 9600: return ((char *) HT_09600
); break;
5546 case 9700: return ((char *) HT_09700
); break;
5547 case 9710: return ((char *) HT_09710
); break;
5548 case 9720: return ((char *) HT_09720
); break;
5549 case 9800: return ((char *) HT_09800
); break;
5550 case 9810: return ((char *) HT_09810
); break;
5551 case 9820: return ((char *) HT_09820
); break;
5552 case 9900: return ((char *) HT_09900
); break;
5553 case 10000: return ((char *) HT_10000
); break;
5554 case 10100: return ((char *) HT_10100
); break;
5555 case 10200: return ((char *) HT_10200
); break;
5556 case 10300: return ((char *) HT_10300
); break;
5557 case 10400: return ((char *) HT_10400
); break;
5558 case 10410: return ((char *) HT_10410
); break;
5559 case 10420: return ((char *) HT_10420
); break;
5560 case 10500: return ((char *) HT_10500
); break;
5561 case 10600: return ((char *) HT_10600
); break;
5562 case 10700: return ((char *) HT_10700
); break;
5563 case 10800: return ((char *) HT_10800
); break;
5564 case 10900: return ((char *) HT_10900
); break;
5565 case 11000: return ((char *) HT_11000
); break;
5566 case 11100: return ((char *) HT_11100
); break;
5567 case 11200: return ((char *) HT_11200
); break;
5568 case 11300: return ((char *) HT_11300
); break;
5569 case 11400: return ((char *) HT_11400
); break;
5570 case 11500: return ((char *) HT_11500
); break;
5571 case 11600: return ((char *) HT_11600
); break;
5572 case 11700: return ((char *) HT_11700
); break;
5573 case 11800: return ((char *) HT_11800
); break;
5574 case 11900: return ((char *) HT_11900
); break;
5575 case 12000: return ((char *) HT_12000
); break;
5576 case 12100: return ((char *) HT_12100
); break;
5577 case 12200: return ((char *) HT_12200
); break;
5578 case 12300: return ((char *) HT_12300
); break;
5579 case 12400: return ((char *) HT_12400
); break;
5580 case 12500: return ((char *) HT_12500
); break;
5581 case 12600: return ((char *) HT_12600
); break;
5582 case 12700: return ((char *) HT_12700
); break;
5583 case 12800: return ((char *) HT_12800
); break;
5586 return ((char *) "Unknown");
5589 char *strstatus (const uint devices_status
)
5591 switch (devices_status
)
5593 case STATUS_INIT
: return ((char *) ST_0000
); break;
5594 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5595 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5596 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5597 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5598 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5599 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5600 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5601 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5602 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5605 return ((char *) "Unknown");
5608 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5610 uint hash_type
= data
.hash_type
;
5611 uint hash_mode
= data
.hash_mode
;
5612 uint salt_type
= data
.salt_type
;
5613 uint opts_type
= data
.opts_type
;
5614 uint opti_type
= data
.opti_type
;
5615 uint dgst_size
= data
.dgst_size
;
5617 char *hashfile
= data
.hashfile
;
5621 uint digest_buf
[64];
5623 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5625 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5627 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5629 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5635 case HASH_TYPE_DESCRYPT
:
5636 FP (digest_buf
[1], digest_buf
[0], tt
);
5639 case HASH_TYPE_DESRACF
:
5640 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5641 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5643 FP (digest_buf
[1], digest_buf
[0], tt
);
5647 FP (digest_buf
[1], digest_buf
[0], tt
);
5650 case HASH_TYPE_NETNTLM
:
5651 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5652 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5653 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5654 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5656 FP (digest_buf
[1], digest_buf
[0], tt
);
5657 FP (digest_buf
[3], digest_buf
[2], tt
);
5660 case HASH_TYPE_BSDICRYPT
:
5661 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5662 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5664 FP (digest_buf
[1], digest_buf
[0], tt
);
5669 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5674 digest_buf
[0] += MD4M_A
;
5675 digest_buf
[1] += MD4M_B
;
5676 digest_buf
[2] += MD4M_C
;
5677 digest_buf
[3] += MD4M_D
;
5681 digest_buf
[0] += MD5M_A
;
5682 digest_buf
[1] += MD5M_B
;
5683 digest_buf
[2] += MD5M_C
;
5684 digest_buf
[3] += MD5M_D
;
5687 case HASH_TYPE_SHA1
:
5688 digest_buf
[0] += SHA1M_A
;
5689 digest_buf
[1] += SHA1M_B
;
5690 digest_buf
[2] += SHA1M_C
;
5691 digest_buf
[3] += SHA1M_D
;
5692 digest_buf
[4] += SHA1M_E
;
5695 case HASH_TYPE_SHA256
:
5696 digest_buf
[0] += SHA256M_A
;
5697 digest_buf
[1] += SHA256M_B
;
5698 digest_buf
[2] += SHA256M_C
;
5699 digest_buf
[3] += SHA256M_D
;
5700 digest_buf
[4] += SHA256M_E
;
5701 digest_buf
[5] += SHA256M_F
;
5702 digest_buf
[6] += SHA256M_G
;
5703 digest_buf
[7] += SHA256M_H
;
5706 case HASH_TYPE_SHA384
:
5707 digest_buf64
[0] += SHA384M_A
;
5708 digest_buf64
[1] += SHA384M_B
;
5709 digest_buf64
[2] += SHA384M_C
;
5710 digest_buf64
[3] += SHA384M_D
;
5711 digest_buf64
[4] += SHA384M_E
;
5712 digest_buf64
[5] += SHA384M_F
;
5713 digest_buf64
[6] += 0;
5714 digest_buf64
[7] += 0;
5717 case HASH_TYPE_SHA512
:
5718 digest_buf64
[0] += SHA512M_A
;
5719 digest_buf64
[1] += SHA512M_B
;
5720 digest_buf64
[2] += SHA512M_C
;
5721 digest_buf64
[3] += SHA512M_D
;
5722 digest_buf64
[4] += SHA512M_E
;
5723 digest_buf64
[5] += SHA512M_F
;
5724 digest_buf64
[6] += SHA512M_G
;
5725 digest_buf64
[7] += SHA512M_H
;
5730 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5732 if (dgst_size
== DGST_SIZE_4_2
)
5734 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5736 else if (dgst_size
== DGST_SIZE_4_4
)
5738 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5740 else if (dgst_size
== DGST_SIZE_4_5
)
5742 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5744 else if (dgst_size
== DGST_SIZE_4_6
)
5746 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5748 else if (dgst_size
== DGST_SIZE_4_8
)
5750 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5752 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5754 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5756 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5758 else if (hash_type
== HASH_TYPE_SHA384
)
5760 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5762 else if (hash_type
== HASH_TYPE_SHA512
)
5764 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5766 else if (hash_type
== HASH_TYPE_GOST
)
5768 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5771 else if (dgst_size
== DGST_SIZE_4_64
)
5773 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5775 else if (dgst_size
== DGST_SIZE_8_25
)
5777 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5781 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5782 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5783 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5789 memset (&salt
, 0, sizeof (salt_t
));
5791 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5793 char *ptr
= (char *) salt
.salt_buf
;
5795 uint len
= salt
.salt_len
;
5797 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5803 case HASH_TYPE_NETNTLM
:
5805 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5806 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5808 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5814 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5816 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5824 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5826 uint max
= salt
.salt_len
/ 4;
5830 for (uint i
= 0; i
< max
; i
++)
5832 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5836 if (opts_type
& OPTS_TYPE_ST_HEX
)
5840 memset (tmp
, 0, sizeof (tmp
));
5842 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5844 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5849 memcpy (ptr
, tmp
, len
);
5852 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5854 memset (ptr
+ len
, 0, memset_size
);
5856 salt
.salt_len
= len
;
5860 // some modes require special encoding
5863 uint out_buf_plain
[256];
5864 uint out_buf_salt
[256];
5868 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5869 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5871 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5873 char *ptr_plain
= (char *) out_buf_plain
;
5874 char *ptr_salt
= (char *) out_buf_salt
;
5876 if (hash_mode
== 22)
5880 memset (username
, 0, sizeof (username
));
5882 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5884 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5886 uint16_t *ptr
= (uint16_t *) digest_buf
;
5888 tmp_buf
[ 0] = sig
[0];
5889 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5890 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5891 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5892 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5893 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5894 tmp_buf
[ 6] = sig
[1];
5895 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5896 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5897 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5898 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5899 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5900 tmp_buf
[12] = sig
[2];
5901 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5902 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5903 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5904 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5905 tmp_buf
[17] = sig
[3];
5906 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5907 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5908 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5909 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5910 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5911 tmp_buf
[23] = sig
[4];
5912 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5913 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5914 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5915 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5916 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5917 tmp_buf
[29] = sig
[5];
5919 snprintf (out_buf
, len
-1, "%s:%s",
5923 else if (hash_mode
== 23)
5925 // do not show the \nskyper\n part in output
5927 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5929 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5931 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5938 else if (hash_mode
== 101)
5940 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5942 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5943 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5944 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5945 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5946 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5948 memcpy (tmp_buf
, digest_buf
, 20);
5950 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5952 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5954 else if (hash_mode
== 111)
5956 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5958 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5959 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5960 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5961 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5962 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5964 memcpy (tmp_buf
, digest_buf
, 20);
5965 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5967 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5969 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
5971 else if (hash_mode
== 122)
5973 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
5974 (unsigned char *) salt
.salt_buf
,
5981 else if (hash_mode
== 124)
5983 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
5984 (unsigned char *) salt
.salt_buf
,
5991 else if (hash_mode
== 131)
5993 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
5994 (unsigned char *) salt
.salt_buf
,
6002 else if (hash_mode
== 132)
6004 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6005 (unsigned char *) salt
.salt_buf
,
6012 else if (hash_mode
== 133)
6014 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6016 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6017 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6018 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6019 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6020 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6022 memcpy (tmp_buf
, digest_buf
, 20);
6024 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6026 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6028 else if (hash_mode
== 141)
6030 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6032 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6034 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6036 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6038 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6039 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6040 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6041 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6042 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6044 memcpy (tmp_buf
, digest_buf
, 20);
6046 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6050 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6052 else if (hash_mode
== 400)
6054 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6056 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6057 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6058 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6059 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6061 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6063 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6065 else if (hash_mode
== 500)
6067 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6074 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6076 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6078 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6082 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6085 else if (hash_mode
== 501)
6087 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6089 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6090 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6092 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6094 else if (hash_mode
== 1421)
6096 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6098 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6114 else if (hash_mode
== 1441)
6116 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6118 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6120 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6122 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6124 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6125 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6126 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6127 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6128 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6129 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6130 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6131 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6133 memcpy (tmp_buf
, digest_buf
, 32);
6135 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6139 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6141 else if (hash_mode
== 1500)
6143 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6144 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6145 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6146 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6147 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6149 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6151 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6153 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6154 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6156 memcpy (tmp_buf
, digest_buf
, 8);
6158 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6160 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6164 else if (hash_mode
== 1600)
6166 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6168 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6169 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6170 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6171 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6173 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6175 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6177 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6181 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6184 else if (hash_mode
== 1711)
6186 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6188 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6189 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6190 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6191 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6192 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6193 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6194 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6195 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6197 memcpy (tmp_buf
, digest_buf
, 64);
6198 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6200 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6202 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6204 else if (hash_mode
== 1722)
6206 uint
*ptr
= digest_buf
;
6208 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6209 (unsigned char *) salt
.salt_buf
,
6219 else if (hash_mode
== 1731)
6221 uint
*ptr
= digest_buf
;
6223 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6224 (unsigned char *) salt
.salt_buf
,
6234 else if (hash_mode
== 1800)
6238 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6239 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6240 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6241 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6242 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6243 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6244 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6245 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6247 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6249 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6251 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6255 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6258 else if (hash_mode
== 2100)
6262 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6264 salt
.salt_iter
+ 1);
6266 uint signature_len
= strlen (out_buf
);
6268 pos
+= signature_len
;
6269 len
-= signature_len
;
6271 char *salt_ptr
= (char *) salt
.salt_buf
;
6273 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6275 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6276 byte_swap_32 (digest_buf
[0]),
6277 byte_swap_32 (digest_buf
[1]),
6278 byte_swap_32 (digest_buf
[2]),
6279 byte_swap_32 (digest_buf
[3]));
6281 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6283 memcpy (tmp_buf
, digest_buf
, 16);
6285 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6287 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6288 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6289 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6290 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6292 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6293 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6294 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6295 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6297 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6298 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6299 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6300 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6302 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6303 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6304 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6305 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6307 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6308 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6309 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6310 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6314 else if (hash_mode
== 2500)
6316 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6318 wpa_t
*wpa
= &wpas
[salt_pos
];
6322 char *pke_ptr
= (char *) pke
;
6324 for (uint i
= 0; i
< 25; i
++)
6326 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6329 unsigned char mac1
[6];
6330 unsigned char mac2
[6];
6332 memcpy (mac1
, pke_ptr
+ 23, 6);
6333 memcpy (mac2
, pke_ptr
+ 29, 6);
6335 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6336 (char *) salt
.salt_buf
,
6350 else if (hash_mode
== 4400)
6352 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6353 byte_swap_32 (digest_buf
[0]),
6354 byte_swap_32 (digest_buf
[1]),
6355 byte_swap_32 (digest_buf
[2]),
6356 byte_swap_32 (digest_buf
[3]));
6358 else if (hash_mode
== 4700)
6360 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6361 byte_swap_32 (digest_buf
[0]),
6362 byte_swap_32 (digest_buf
[1]),
6363 byte_swap_32 (digest_buf
[2]),
6364 byte_swap_32 (digest_buf
[3]),
6365 byte_swap_32 (digest_buf
[4]));
6367 else if (hash_mode
== 4800)
6369 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6376 byte_swap_32 (salt
.salt_buf
[0]),
6377 byte_swap_32 (salt
.salt_buf
[1]),
6378 byte_swap_32 (salt
.salt_buf
[2]),
6379 byte_swap_32 (salt
.salt_buf
[3]),
6382 else if (hash_mode
== 4900)
6384 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6385 byte_swap_32 (digest_buf
[0]),
6386 byte_swap_32 (digest_buf
[1]),
6387 byte_swap_32 (digest_buf
[2]),
6388 byte_swap_32 (digest_buf
[3]),
6389 byte_swap_32 (digest_buf
[4]));
6391 else if (hash_mode
== 5100)
6393 snprintf (out_buf
, len
-1, "%08x%08x",
6397 else if (hash_mode
== 5200)
6399 snprintf (out_buf
, len
-1, "%s", hashfile
);
6401 else if (hash_mode
== 5300)
6403 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6405 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6407 int buf_len
= len
-1;
6411 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6413 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6415 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6417 snprintf (out_buf
, buf_len
, ":");
6423 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6431 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6433 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6435 if ((i
== 0) || (i
== 5))
6437 snprintf (out_buf
, buf_len
, ":");
6443 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6451 for (uint i
= 0; i
< 4; i
++)
6455 snprintf (out_buf
, buf_len
, ":");
6461 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6467 else if (hash_mode
== 5400)
6469 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6471 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6473 int buf_len
= len
-1;
6477 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6479 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6481 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6483 snprintf (out_buf
, buf_len
, ":");
6489 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6497 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6499 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6501 if ((i
== 0) || (i
== 5))
6503 snprintf (out_buf
, buf_len
, ":");
6509 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6517 for (uint i
= 0; i
< 5; i
++)
6521 snprintf (out_buf
, buf_len
, ":");
6527 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6533 else if (hash_mode
== 5500)
6535 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6537 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6540 char domain_buf
[64];
6541 char srvchall_buf
[1024];
6542 char clichall_buf
[1024];
6544 memset (user_buf
, 0, sizeof (user_buf
));
6545 memset (domain_buf
, 0, sizeof (domain_buf
));
6546 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6547 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6549 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6551 char *ptr
= (char *) netntlm
->userdomain_buf
;
6553 user_buf
[i
] = ptr
[j
];
6556 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6558 char *ptr
= (char *) netntlm
->userdomain_buf
;
6560 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6563 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6565 char *ptr
= (char *) netntlm
->chall_buf
;
6567 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6570 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6572 char *ptr
= (char *) netntlm
->chall_buf
;
6574 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6577 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6585 byte_swap_32 (salt
.salt_buf_pc
[0]),
6586 byte_swap_32 (salt
.salt_buf_pc
[1]),
6589 else if (hash_mode
== 5600)
6591 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6593 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6596 char domain_buf
[64];
6597 char srvchall_buf
[1024];
6598 char clichall_buf
[1024];
6600 memset (user_buf
, 0, sizeof (user_buf
));
6601 memset (domain_buf
, 0, sizeof (domain_buf
));
6602 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6603 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6605 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6607 char *ptr
= (char *) netntlm
->userdomain_buf
;
6609 user_buf
[i
] = ptr
[j
];
6612 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6614 char *ptr
= (char *) netntlm
->userdomain_buf
;
6616 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6619 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6621 char *ptr
= (char *) netntlm
->chall_buf
;
6623 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6626 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6628 char *ptr
= (char *) netntlm
->chall_buf
;
6630 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6633 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6643 else if (hash_mode
== 5700)
6645 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6647 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6648 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6649 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6650 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6651 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6652 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6653 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6654 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6656 memcpy (tmp_buf
, digest_buf
, 32);
6658 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6662 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6664 else if (hash_mode
== 5800)
6666 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6667 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6668 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6669 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6670 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6672 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6679 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6681 snprintf (out_buf
, len
-1, "%s", hashfile
);
6683 else if (hash_mode
== 6300)
6685 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6687 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6688 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6689 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6690 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6692 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6694 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6696 else if (hash_mode
== 6400)
6698 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6700 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6702 else if (hash_mode
== 6500)
6704 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6706 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6708 else if (hash_mode
== 6600)
6710 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6712 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6714 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6715 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6717 uint buf_len
= len
- 1;
6719 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6722 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6724 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6729 else if (hash_mode
== 6700)
6731 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6733 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6735 else if (hash_mode
== 6800)
6737 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6739 else if (hash_mode
== 7100)
6741 uint
*ptr
= digest_buf
;
6743 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6745 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6749 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6750 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6751 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6752 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6753 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6754 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6755 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6756 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6758 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6759 SIGNATURE_SHA512OSX
,
6761 esalt
[ 0], esalt
[ 1],
6762 esalt
[ 2], esalt
[ 3],
6763 esalt
[ 4], esalt
[ 5],
6764 esalt
[ 6], esalt
[ 7],
6772 ptr
[15], ptr
[14]);
6774 else if (hash_mode
== 7200)
6776 uint
*ptr
= digest_buf
;
6778 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6780 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6784 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6786 len_used
= strlen (out_buf
);
6788 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6790 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6792 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6795 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6803 ptr
[15], ptr
[14]);
6805 else if (hash_mode
== 7300)
6807 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6809 rakp_t
*rakp
= &rakps
[salt_pos
];
6811 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6813 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6816 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6823 else if (hash_mode
== 7400)
6825 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6827 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6828 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6829 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6830 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6831 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6832 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6833 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6834 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6836 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6838 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6840 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6844 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6847 else if (hash_mode
== 7500)
6849 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6851 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6853 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6854 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6858 char *ptr_data
= data
;
6860 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6862 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6865 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6867 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6872 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6874 (char *) krb5pa
->user
,
6875 (char *) krb5pa
->realm
,
6876 (char *) krb5pa
->salt
,
6879 else if (hash_mode
== 7700)
6881 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6882 (char *) salt
.salt_buf
,
6886 else if (hash_mode
== 7800)
6888 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6889 (char *) salt
.salt_buf
,
6896 else if (hash_mode
== 7900)
6898 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6902 char *tmp
= (char *) salt
.salt_buf_pc
;
6904 ptr_plain
[42] = tmp
[0];
6910 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6912 else if (hash_mode
== 8000)
6914 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6915 (unsigned char *) salt
.salt_buf
,
6925 else if (hash_mode
== 8100)
6927 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6928 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6930 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6931 (unsigned char *) salt
.salt_buf
,
6938 else if (hash_mode
== 8200)
6940 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6942 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6944 char data_buf
[4096];
6946 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6948 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6951 data_buf
[cloudkey
->data_len
* 2] = 0;
6953 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6954 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6955 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6956 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6957 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6958 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6959 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6960 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6962 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6963 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6964 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6965 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6967 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
6983 else if (hash_mode
== 8300)
6987 char digest_buf_c
[33];
6989 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
6991 digest_buf_c
[32] = 0;
6995 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
6997 char domain_buf_c
[33];
6999 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7001 for (uint i
= 0; i
< salt_pc_len
; i
++)
7003 const char next
= domain_buf_c
[i
];
7005 domain_buf_c
[i
] = '.';
7010 domain_buf_c
[salt_pc_len
] = 0;
7014 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7016 else if (hash_mode
== 8500)
7018 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7020 else if (hash_mode
== 2612)
7022 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7024 (char *) salt
.salt_buf
,
7030 else if (hash_mode
== 3711)
7032 char *salt_ptr
= (char *) salt
.salt_buf
;
7034 salt_ptr
[salt
.salt_len
- 1] = 0;
7036 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7037 SIGNATURE_MEDIAWIKI_B
,
7044 else if (hash_mode
== 8800)
7046 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7048 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7052 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7054 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7059 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7060 SIGNATURE_ANDROIDFDE
,
7061 byte_swap_32 (salt
.salt_buf
[0]),
7062 byte_swap_32 (salt
.salt_buf
[1]),
7063 byte_swap_32 (salt
.salt_buf
[2]),
7064 byte_swap_32 (salt
.salt_buf
[3]),
7065 byte_swap_32 (digest_buf
[0]),
7066 byte_swap_32 (digest_buf
[1]),
7067 byte_swap_32 (digest_buf
[2]),
7068 byte_swap_32 (digest_buf
[3]),
7071 else if (hash_mode
== 8900)
7073 uint N
= salt
.scrypt_N
;
7074 uint r
= salt
.scrypt_r
;
7075 uint p
= salt
.scrypt_p
;
7077 char base64_salt
[32];
7079 memset (base64_salt
, 0, 32);
7081 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7083 memset (tmp_buf
, 0, 46);
7085 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7086 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7087 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7088 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7089 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7090 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7091 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7092 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7093 digest_buf
[8] = 0; // needed for base64_encode ()
7095 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7097 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7105 else if (hash_mode
== 9000)
7107 snprintf (out_buf
, len
-1, "%s", hashfile
);
7109 else if (hash_mode
== 9200)
7113 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7115 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7117 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7123 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7124 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7125 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7126 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7127 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7128 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7129 digest_buf
[8] = 0; // needed for base64_encode ()
7132 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7134 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7135 tmp_buf
[43] = 0; // cut it here
7139 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7141 else if (hash_mode
== 9300)
7143 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7144 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7145 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7146 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7147 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7148 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7149 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7150 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7151 digest_buf
[8] = 0; // needed for base64_encode ()
7154 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7156 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7157 tmp_buf
[43] = 0; // cut it here
7159 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7161 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7163 else if (hash_mode
== 9400)
7165 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7167 office2007_t
*office2007
= &office2007s
[salt_pos
];
7169 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7170 SIGNATURE_OFFICE2007
,
7173 office2007
->keySize
,
7179 office2007
->encryptedVerifier
[0],
7180 office2007
->encryptedVerifier
[1],
7181 office2007
->encryptedVerifier
[2],
7182 office2007
->encryptedVerifier
[3],
7183 office2007
->encryptedVerifierHash
[0],
7184 office2007
->encryptedVerifierHash
[1],
7185 office2007
->encryptedVerifierHash
[2],
7186 office2007
->encryptedVerifierHash
[3],
7187 office2007
->encryptedVerifierHash
[4]);
7189 else if (hash_mode
== 9500)
7191 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7193 office2010_t
*office2010
= &office2010s
[salt_pos
];
7195 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7201 office2010
->encryptedVerifier
[0],
7202 office2010
->encryptedVerifier
[1],
7203 office2010
->encryptedVerifier
[2],
7204 office2010
->encryptedVerifier
[3],
7205 office2010
->encryptedVerifierHash
[0],
7206 office2010
->encryptedVerifierHash
[1],
7207 office2010
->encryptedVerifierHash
[2],
7208 office2010
->encryptedVerifierHash
[3],
7209 office2010
->encryptedVerifierHash
[4],
7210 office2010
->encryptedVerifierHash
[5],
7211 office2010
->encryptedVerifierHash
[6],
7212 office2010
->encryptedVerifierHash
[7]);
7214 else if (hash_mode
== 9600)
7216 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7218 office2013_t
*office2013
= &office2013s
[salt_pos
];
7220 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7226 office2013
->encryptedVerifier
[0],
7227 office2013
->encryptedVerifier
[1],
7228 office2013
->encryptedVerifier
[2],
7229 office2013
->encryptedVerifier
[3],
7230 office2013
->encryptedVerifierHash
[0],
7231 office2013
->encryptedVerifierHash
[1],
7232 office2013
->encryptedVerifierHash
[2],
7233 office2013
->encryptedVerifierHash
[3],
7234 office2013
->encryptedVerifierHash
[4],
7235 office2013
->encryptedVerifierHash
[5],
7236 office2013
->encryptedVerifierHash
[6],
7237 office2013
->encryptedVerifierHash
[7]);
7239 else if (hash_mode
== 9700)
7241 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7243 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7245 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7246 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7247 byte_swap_32 (salt
.salt_buf
[0]),
7248 byte_swap_32 (salt
.salt_buf
[1]),
7249 byte_swap_32 (salt
.salt_buf
[2]),
7250 byte_swap_32 (salt
.salt_buf
[3]),
7251 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7252 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7253 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7254 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7255 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7256 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7257 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7258 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7260 else if (hash_mode
== 9710)
7262 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7264 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7266 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7267 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7268 byte_swap_32 (salt
.salt_buf
[0]),
7269 byte_swap_32 (salt
.salt_buf
[1]),
7270 byte_swap_32 (salt
.salt_buf
[2]),
7271 byte_swap_32 (salt
.salt_buf
[3]),
7272 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7273 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7274 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7275 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7276 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7277 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7278 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7279 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7281 else if (hash_mode
== 9720)
7283 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7285 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7287 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7289 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7290 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7291 byte_swap_32 (salt
.salt_buf
[0]),
7292 byte_swap_32 (salt
.salt_buf
[1]),
7293 byte_swap_32 (salt
.salt_buf
[2]),
7294 byte_swap_32 (salt
.salt_buf
[3]),
7295 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7296 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7297 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7298 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7299 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7300 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7301 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7302 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7309 else if (hash_mode
== 9800)
7311 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7313 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7315 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7316 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7321 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7322 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7323 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7324 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7325 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7326 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7327 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7328 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7329 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7331 else if (hash_mode
== 9810)
7333 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7335 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7337 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7338 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7343 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7344 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7345 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7346 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7347 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7348 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7349 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7350 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7351 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7353 else if (hash_mode
== 9820)
7355 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7357 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7359 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7361 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7362 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7367 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7368 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7369 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7370 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7371 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7372 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7373 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7374 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7375 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7382 else if (hash_mode
== 10000)
7386 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7388 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7390 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7394 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7395 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7396 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7397 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7398 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7399 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7400 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7401 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7402 digest_buf
[8] = 0; // needed for base64_encode ()
7405 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7407 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7411 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7413 else if (hash_mode
== 10100)
7415 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7420 byte_swap_32 (salt
.salt_buf
[0]),
7421 byte_swap_32 (salt
.salt_buf
[1]),
7422 byte_swap_32 (salt
.salt_buf
[2]),
7423 byte_swap_32 (salt
.salt_buf
[3]));
7425 else if (hash_mode
== 10200)
7427 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7429 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7433 char challenge
[100];
7435 memset (challenge
, 0, sizeof (challenge
));
7437 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7443 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7444 (char *) cram_md5
->user
,
7452 memset (response
, 0, sizeof (response
));
7454 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7456 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7458 else if (hash_mode
== 10300)
7462 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7464 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7465 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7467 uint tmp_len
= 20 + salt
.salt_len
;
7471 char base64_encoded
[100];
7473 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7475 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7477 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7479 else if (hash_mode
== 10400)
7481 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7483 pdf_t
*pdf
= &pdfs
[salt_pos
];
7485 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7493 byte_swap_32 (pdf
->id_buf
[0]),
7494 byte_swap_32 (pdf
->id_buf
[1]),
7495 byte_swap_32 (pdf
->id_buf
[2]),
7496 byte_swap_32 (pdf
->id_buf
[3]),
7498 byte_swap_32 (pdf
->u_buf
[0]),
7499 byte_swap_32 (pdf
->u_buf
[1]),
7500 byte_swap_32 (pdf
->u_buf
[2]),
7501 byte_swap_32 (pdf
->u_buf
[3]),
7502 byte_swap_32 (pdf
->u_buf
[4]),
7503 byte_swap_32 (pdf
->u_buf
[5]),
7504 byte_swap_32 (pdf
->u_buf
[6]),
7505 byte_swap_32 (pdf
->u_buf
[7]),
7507 byte_swap_32 (pdf
->o_buf
[0]),
7508 byte_swap_32 (pdf
->o_buf
[1]),
7509 byte_swap_32 (pdf
->o_buf
[2]),
7510 byte_swap_32 (pdf
->o_buf
[3]),
7511 byte_swap_32 (pdf
->o_buf
[4]),
7512 byte_swap_32 (pdf
->o_buf
[5]),
7513 byte_swap_32 (pdf
->o_buf
[6]),
7514 byte_swap_32 (pdf
->o_buf
[7])
7517 else if (hash_mode
== 10410)
7519 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7521 pdf_t
*pdf
= &pdfs
[salt_pos
];
7523 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7531 byte_swap_32 (pdf
->id_buf
[0]),
7532 byte_swap_32 (pdf
->id_buf
[1]),
7533 byte_swap_32 (pdf
->id_buf
[2]),
7534 byte_swap_32 (pdf
->id_buf
[3]),
7536 byte_swap_32 (pdf
->u_buf
[0]),
7537 byte_swap_32 (pdf
->u_buf
[1]),
7538 byte_swap_32 (pdf
->u_buf
[2]),
7539 byte_swap_32 (pdf
->u_buf
[3]),
7540 byte_swap_32 (pdf
->u_buf
[4]),
7541 byte_swap_32 (pdf
->u_buf
[5]),
7542 byte_swap_32 (pdf
->u_buf
[6]),
7543 byte_swap_32 (pdf
->u_buf
[7]),
7545 byte_swap_32 (pdf
->o_buf
[0]),
7546 byte_swap_32 (pdf
->o_buf
[1]),
7547 byte_swap_32 (pdf
->o_buf
[2]),
7548 byte_swap_32 (pdf
->o_buf
[3]),
7549 byte_swap_32 (pdf
->o_buf
[4]),
7550 byte_swap_32 (pdf
->o_buf
[5]),
7551 byte_swap_32 (pdf
->o_buf
[6]),
7552 byte_swap_32 (pdf
->o_buf
[7])
7555 else if (hash_mode
== 10420)
7557 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7559 pdf_t
*pdf
= &pdfs
[salt_pos
];
7561 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7563 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7571 byte_swap_32 (pdf
->id_buf
[0]),
7572 byte_swap_32 (pdf
->id_buf
[1]),
7573 byte_swap_32 (pdf
->id_buf
[2]),
7574 byte_swap_32 (pdf
->id_buf
[3]),
7576 byte_swap_32 (pdf
->u_buf
[0]),
7577 byte_swap_32 (pdf
->u_buf
[1]),
7578 byte_swap_32 (pdf
->u_buf
[2]),
7579 byte_swap_32 (pdf
->u_buf
[3]),
7580 byte_swap_32 (pdf
->u_buf
[4]),
7581 byte_swap_32 (pdf
->u_buf
[5]),
7582 byte_swap_32 (pdf
->u_buf
[6]),
7583 byte_swap_32 (pdf
->u_buf
[7]),
7585 byte_swap_32 (pdf
->o_buf
[0]),
7586 byte_swap_32 (pdf
->o_buf
[1]),
7587 byte_swap_32 (pdf
->o_buf
[2]),
7588 byte_swap_32 (pdf
->o_buf
[3]),
7589 byte_swap_32 (pdf
->o_buf
[4]),
7590 byte_swap_32 (pdf
->o_buf
[5]),
7591 byte_swap_32 (pdf
->o_buf
[6]),
7592 byte_swap_32 (pdf
->o_buf
[7]),
7600 else if (hash_mode
== 10500)
7602 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7604 pdf_t
*pdf
= &pdfs
[salt_pos
];
7606 if (pdf
->id_len
== 32)
7608 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7616 byte_swap_32 (pdf
->id_buf
[0]),
7617 byte_swap_32 (pdf
->id_buf
[1]),
7618 byte_swap_32 (pdf
->id_buf
[2]),
7619 byte_swap_32 (pdf
->id_buf
[3]),
7620 byte_swap_32 (pdf
->id_buf
[4]),
7621 byte_swap_32 (pdf
->id_buf
[5]),
7622 byte_swap_32 (pdf
->id_buf
[6]),
7623 byte_swap_32 (pdf
->id_buf
[7]),
7625 byte_swap_32 (pdf
->u_buf
[0]),
7626 byte_swap_32 (pdf
->u_buf
[1]),
7627 byte_swap_32 (pdf
->u_buf
[2]),
7628 byte_swap_32 (pdf
->u_buf
[3]),
7629 byte_swap_32 (pdf
->u_buf
[4]),
7630 byte_swap_32 (pdf
->u_buf
[5]),
7631 byte_swap_32 (pdf
->u_buf
[6]),
7632 byte_swap_32 (pdf
->u_buf
[7]),
7634 byte_swap_32 (pdf
->o_buf
[0]),
7635 byte_swap_32 (pdf
->o_buf
[1]),
7636 byte_swap_32 (pdf
->o_buf
[2]),
7637 byte_swap_32 (pdf
->o_buf
[3]),
7638 byte_swap_32 (pdf
->o_buf
[4]),
7639 byte_swap_32 (pdf
->o_buf
[5]),
7640 byte_swap_32 (pdf
->o_buf
[6]),
7641 byte_swap_32 (pdf
->o_buf
[7])
7646 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7654 byte_swap_32 (pdf
->id_buf
[0]),
7655 byte_swap_32 (pdf
->id_buf
[1]),
7656 byte_swap_32 (pdf
->id_buf
[2]),
7657 byte_swap_32 (pdf
->id_buf
[3]),
7659 byte_swap_32 (pdf
->u_buf
[0]),
7660 byte_swap_32 (pdf
->u_buf
[1]),
7661 byte_swap_32 (pdf
->u_buf
[2]),
7662 byte_swap_32 (pdf
->u_buf
[3]),
7663 byte_swap_32 (pdf
->u_buf
[4]),
7664 byte_swap_32 (pdf
->u_buf
[5]),
7665 byte_swap_32 (pdf
->u_buf
[6]),
7666 byte_swap_32 (pdf
->u_buf
[7]),
7668 byte_swap_32 (pdf
->o_buf
[0]),
7669 byte_swap_32 (pdf
->o_buf
[1]),
7670 byte_swap_32 (pdf
->o_buf
[2]),
7671 byte_swap_32 (pdf
->o_buf
[3]),
7672 byte_swap_32 (pdf
->o_buf
[4]),
7673 byte_swap_32 (pdf
->o_buf
[5]),
7674 byte_swap_32 (pdf
->o_buf
[6]),
7675 byte_swap_32 (pdf
->o_buf
[7])
7679 else if (hash_mode
== 10600)
7681 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7683 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7684 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7686 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7688 else if (hash_mode
== 10700)
7690 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7692 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7693 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7695 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7697 else if (hash_mode
== 10900)
7699 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7701 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7702 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7704 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7706 else if (hash_mode
== 11100)
7708 uint32_t salt_challenge
= salt
.salt_buf
[0];
7710 salt_challenge
= byte_swap_32 (salt_challenge
);
7712 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7714 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7715 SIGNATURE_POSTGRESQL_AUTH
,
7723 else if (hash_mode
== 11200)
7725 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7726 SIGNATURE_MYSQL_AUTH
,
7727 (unsigned char *) salt
.salt_buf
,
7734 else if (hash_mode
== 11300)
7736 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7738 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7740 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7741 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7742 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7744 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7745 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7746 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7748 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7750 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7752 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7755 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7757 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7759 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7762 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7764 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7766 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7769 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7770 SIGNATURE_BITCOIN_WALLET
,
7774 (unsigned char *) salt
.salt_buf
,
7782 free (cry_master_buf
);
7784 free (public_key_buf
);
7786 else if (hash_mode
== 11400)
7788 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7790 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7791 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7793 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7795 else if (hash_mode
== 11600)
7797 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7799 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7801 const uint data_len
= seven_zip
->data_len
;
7803 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7805 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7807 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7809 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7812 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7813 SIGNATURE_SEVEN_ZIP
,
7817 (char *) seven_zip
->salt_buf
,
7819 seven_zip
->iv_buf
[0],
7820 seven_zip
->iv_buf
[1],
7821 seven_zip
->iv_buf
[2],
7822 seven_zip
->iv_buf
[3],
7824 seven_zip
->data_len
,
7825 seven_zip
->unpack_size
,
7830 else if (hash_mode
== 11700)
7832 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7842 else if (hash_mode
== 11800)
7844 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7862 else if (hash_mode
== 11900)
7864 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7866 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7867 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7869 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7871 else if (hash_mode
== 12000)
7873 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7875 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7876 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7878 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7880 else if (hash_mode
== 12100)
7882 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7884 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7885 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7887 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7889 else if (hash_mode
== 12200)
7891 uint
*ptr_digest
= digest_buf
;
7892 uint
*ptr_salt
= salt
.salt_buf
;
7894 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7901 else if (hash_mode
== 12300)
7903 uint
*ptr_digest
= digest_buf
;
7904 uint
*ptr_salt
= salt
.salt_buf
;
7906 snprintf (out_buf
, len
-1, "%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
7907 ptr_digest
[ 0], ptr_digest
[ 1],
7908 ptr_digest
[ 2], ptr_digest
[ 3],
7909 ptr_digest
[ 4], ptr_digest
[ 5],
7910 ptr_digest
[ 6], ptr_digest
[ 7],
7911 ptr_digest
[ 8], ptr_digest
[ 9],
7912 ptr_digest
[10], ptr_digest
[11],
7913 ptr_digest
[12], ptr_digest
[13],
7914 ptr_digest
[14], ptr_digest
[15],
7920 else if (hash_mode
== 12400)
7922 // encode iteration count
7926 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7927 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7928 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7929 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7934 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7935 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7936 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7937 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7942 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7944 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7945 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7947 memcpy (tmp_buf
, digest_buf
, 8);
7949 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7953 // fill the resulting buffer
7955 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7957 else if (hash_mode
== 12500)
7959 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7961 byte_swap_32 (salt
.salt_buf
[0]),
7962 byte_swap_32 (salt
.salt_buf
[1]),
7968 else if (hash_mode
== 12600)
7970 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7971 digest_buf
[0] + salt
.salt_buf_pc
[0],
7972 digest_buf
[1] + salt
.salt_buf_pc
[1],
7973 digest_buf
[2] + salt
.salt_buf_pc
[2],
7974 digest_buf
[3] + salt
.salt_buf_pc
[3],
7975 digest_buf
[4] + salt
.salt_buf_pc
[4],
7976 digest_buf
[5] + salt
.salt_buf_pc
[5],
7977 digest_buf
[6] + salt
.salt_buf_pc
[6],
7978 digest_buf
[7] + salt
.salt_buf_pc
[7]);
7980 else if (hash_mode
== 12700)
7982 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7984 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7985 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7987 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7989 else if (hash_mode
== 12800)
7991 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
7993 snprintf (out_buf
, len
-1, "%s,%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x,%d,%08x%08x%08x%08x%08x%08x%08x%08x",
8006 byte_swap_32 (digest_buf
[0]),
8007 byte_swap_32 (digest_buf
[1]),
8008 byte_swap_32 (digest_buf
[2]),
8009 byte_swap_32 (digest_buf
[3]),
8010 byte_swap_32 (digest_buf
[4]),
8011 byte_swap_32 (digest_buf
[5]),
8012 byte_swap_32 (digest_buf
[6]),
8013 byte_swap_32 (digest_buf
[7])
8018 if (hash_type
== HASH_TYPE_MD4
)
8020 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8026 else if (hash_type
== HASH_TYPE_MD5
)
8028 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8034 else if (hash_type
== HASH_TYPE_SHA1
)
8036 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8043 else if (hash_type
== HASH_TYPE_SHA256
)
8045 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8055 else if (hash_type
== HASH_TYPE_SHA384
)
8057 uint
*ptr
= digest_buf
;
8059 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8067 else if (hash_type
== HASH_TYPE_SHA512
)
8069 uint
*ptr
= digest_buf
;
8071 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8081 else if (hash_type
== HASH_TYPE_LM
)
8083 snprintf (out_buf
, len
-1, "%08x%08x",
8087 else if (hash_type
== HASH_TYPE_ORACLEH
)
8089 snprintf (out_buf
, len
-1, "%08X%08X",
8093 else if (hash_type
== HASH_TYPE_BCRYPT
)
8095 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8096 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8098 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8100 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8102 else if (hash_type
== HASH_TYPE_KECCAK
)
8104 uint
*ptr
= digest_buf
;
8106 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8134 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8136 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8138 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8145 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8147 digest_buf
[ 0] = digest_buf
[ 0];
8148 digest_buf
[ 1] = digest_buf
[ 1];
8149 digest_buf
[ 2] = digest_buf
[ 2];
8150 digest_buf
[ 3] = digest_buf
[ 3];
8151 digest_buf
[ 4] = digest_buf
[ 4];
8152 digest_buf
[ 5] = digest_buf
[ 5];
8153 digest_buf
[ 6] = digest_buf
[ 6];
8154 digest_buf
[ 7] = digest_buf
[ 7];
8155 digest_buf
[ 8] = digest_buf
[ 8];
8156 digest_buf
[ 9] = digest_buf
[ 9];
8157 digest_buf
[10] = digest_buf
[10];
8158 digest_buf
[11] = digest_buf
[11];
8159 digest_buf
[12] = digest_buf
[12];
8160 digest_buf
[13] = digest_buf
[13];
8161 digest_buf
[14] = digest_buf
[14];
8162 digest_buf
[15] = digest_buf
[15];
8164 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8182 else if (hash_type
== HASH_TYPE_GOST
)
8184 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8194 else if (hash_type
== HASH_TYPE_MYSQL
)
8196 snprintf (out_buf
, len
-1, "%08x%08x",
8200 else if (hash_type
== HASH_TYPE_LOTUS5
)
8202 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8208 else if (hash_type
== HASH_TYPE_LOTUS6
)
8210 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8211 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8212 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8213 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8217 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8218 memcpy (buf
+ 5, digest_buf
, 9);
8222 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8224 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8227 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8229 else if (hash_type
== HASH_TYPE_LOTUS8
)
8233 memset (buf
, 0, sizeof (buf
));
8237 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8243 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8247 buf
[26] = salt
.salt_buf_pc
[0];
8248 buf
[27] = salt
.salt_buf_pc
[1];
8252 memcpy (buf
+ 28, digest_buf
, 8);
8254 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8258 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8260 else if (hash_type
== HASH_TYPE_CRC32
)
8262 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8266 if (salt_type
== SALT_TYPE_INTERN
)
8268 size_t pos
= strlen (out_buf
);
8270 out_buf
[pos
] = data
.separator
;
8272 char *ptr
= (char *) salt
.salt_buf
;
8274 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8276 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8280 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8282 memset (hccap
, 0, sizeof (hccap_t
));
8284 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8286 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8288 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8289 wpa_t
*wpa
= &wpas
[salt_pos
];
8291 hccap
->keyver
= wpa
->keyver
;
8293 hccap
->eapol_size
= wpa
->eapol_size
;
8295 if (wpa
->keyver
!= 1)
8299 for (uint i
= 0; i
< 64; i
++)
8301 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8304 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8308 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8313 for (int i
= 5; i
< 25; i
++)
8315 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8318 char *pke_ptr
= (char *) pke_tmp
;
8320 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8321 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8322 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8323 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8325 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8327 uint dgst_size
= data
.dgst_size
;
8329 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8331 if (wpa
->keyver
!= 1)
8335 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8336 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8337 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8338 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8340 memcpy (hccap
->keymic
, digest_tmp
, 16);
8344 memcpy (hccap
->keymic
, digest_ptr
, 16);
8348 void SuspendThreads ()
8350 if (data
.devices_status
== STATUS_RUNNING
)
8352 hc_timer_set (&data
.timer_paused
);
8354 data
.devices_status
= STATUS_PAUSED
;
8356 log_info ("Paused");
8360 void ResumeThreads ()
8362 if (data
.devices_status
== STATUS_PAUSED
)
8366 hc_timer_get (data
.timer_paused
, ms_paused
);
8368 data
.ms_paused
+= ms_paused
;
8370 data
.devices_status
= STATUS_RUNNING
;
8372 log_info ("Resumed");
8378 if (data
.devices_status
!= STATUS_RUNNING
) return;
8380 data
.devices_status
= STATUS_BYPASS
;
8382 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8385 void stop_at_checkpoint ()
8387 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8389 if (data
.devices_status
!= STATUS_RUNNING
) return;
8392 // this feature only makes sense if --restore-disable was not specified
8394 if (data
.restore_disable
== 1)
8396 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8401 // check if monitoring of Restore Point updates should be enabled or disabled
8403 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8405 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8407 // save the current restore point value
8409 data
.checkpoint_cur_words
= get_lowest_words_done ();
8411 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8415 data
.devices_status
= STATUS_RUNNING
;
8417 // reset the global value for checkpoint checks
8419 data
.checkpoint_cur_words
= 0;
8421 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8427 if (data
.devices_status
== STATUS_INIT
) return;
8428 if (data
.devices_status
== STATUS_STARTING
) return;
8430 data
.devices_status
= STATUS_ABORTED
;
8435 if (data
.devices_status
== STATUS_INIT
) return;
8436 if (data
.devices_status
== STATUS_STARTING
) return;
8438 data
.devices_status
= STATUS_QUIT
;
8441 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8445 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8449 memset (&st
, 0, sizeof (st
));
8451 stat (kernel_file
, &st
);
8453 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8455 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8457 if (num_read
!= (size_t) st
.st_size
)
8459 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8466 buf
[st
.st_size
] = 0;
8468 for (int i
= 0; i
< num_devices
; i
++)
8470 kernel_lengths
[i
] = (size_t) st
.st_size
;
8472 kernel_sources
[i
] = buf
;
8477 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8485 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8487 FILE *fp
= fopen (dst
, "wb");
8489 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8499 restore_data_t
*init_restore (int argc
, char **argv
)
8501 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8503 if (data
.restore_disable
== 0)
8505 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8509 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8513 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8522 char pidbin
[BUFSIZ
];
8527 memset (pidbin
, 0, sizeof (pidbin
));
8529 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8531 FILE *fd
= fopen (pidbin
, "rb");
8535 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8537 pidbin
[pidbin_len
] = 0;
8541 char *argv0_r
= strrchr (argv
[0], '/');
8543 char *pidbin_r
= strrchr (pidbin
, '/');
8545 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8547 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8549 if (strcmp (argv0_r
, pidbin_r
) == 0)
8551 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8558 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8560 char pidbin2
[BUFSIZ
];
8564 memset (pidbin2
, 0, sizeof (pidbin2
));
8566 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8567 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8569 pidbin
[pidbin_len
] = 0;
8570 pidbin2
[pidbin2_len
] = 0;
8574 if (strcmp (pidbin
, pidbin2
) == 0)
8576 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8584 if (rd
->version_bin
< RESTORE_MIN
)
8586 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8593 memset (rd
, 0, sizeof (restore_data_t
));
8595 rd
->version_bin
= VERSION_BIN
;
8598 rd
->pid
= getpid ();
8600 rd
->pid
= GetCurrentProcessId ();
8603 if (getcwd (rd
->cwd
, 255) == NULL
)
8616 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8618 FILE *fp
= fopen (eff_restore_file
, "rb");
8622 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8627 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8629 log_error ("ERROR: cannot read %s", eff_restore_file
);
8634 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8636 for (uint i
= 0; i
< rd
->argc
; i
++)
8640 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8642 log_error ("ERROR: cannot read %s", eff_restore_file
);
8647 size_t len
= strlen (buf
);
8649 if (len
) buf
[len
- 1] = 0;
8651 rd
->argv
[i
] = mystrdup (buf
);
8658 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8662 log_error ("Restore file is corrupted");
8665 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8667 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8669 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8674 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8678 if (chdir (rd
->cwd
))
8680 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8686 uint64_t get_lowest_words_done ()
8688 uint64_t words_cur
= -1;
8690 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8692 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8694 const uint64_t words_done
= device_param
->words_done
;
8696 if (words_done
< words_cur
) words_cur
= words_done
;
8699 // It's possible that a GPU's workload isn't finished right after a restore-case.
8700 // In that case, this function would return 0 and overwrite the real restore point
8701 // There's also data.words_cur which is set to rd->words_cur but it changes while
8702 // the attack is running therefore we should stick to rd->words_cur.
8703 // Note that -s influences rd->words_cur we should keep a close look on that.
8705 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8710 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8712 uint64_t words_cur
= get_lowest_words_done ();
8714 rd
->words_cur
= words_cur
;
8716 FILE *fp
= fopen (new_restore_file
, "wb");
8720 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8725 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8727 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8732 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8734 for (uint i
= 0; i
< rd
->argc
; i
++)
8736 fprintf (fp
, "%s", rd
->argv
[i
]);
8742 fsync (fileno (fp
));
8747 void cycle_restore ()
8749 const char *eff_restore_file
= data
.eff_restore_file
;
8750 const char *new_restore_file
= data
.new_restore_file
;
8752 restore_data_t
*rd
= data
.rd
;
8754 write_restore (new_restore_file
, rd
);
8758 memset (&st
, 0, sizeof(st
));
8760 if (stat (eff_restore_file
, &st
) == 0)
8762 if (unlink (eff_restore_file
))
8764 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8768 if (rename (new_restore_file
, eff_restore_file
))
8770 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8774 void check_checkpoint ()
8776 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8778 uint64_t words_cur
= get_lowest_words_done ();
8780 if (words_cur
!= data
.checkpoint_cur_words
)
8790 uint
set_gpu_accel (uint hash_mode
)
8794 case 0: return GET_ACCEL (0);
8795 case 10: return GET_ACCEL (10);
8796 case 11: return GET_ACCEL (11);
8797 case 12: return GET_ACCEL (12);
8798 case 20: return GET_ACCEL (20);
8799 case 21: return GET_ACCEL (21);
8800 case 22: return GET_ACCEL (22);
8801 case 23: return GET_ACCEL (23);
8802 case 30: return GET_ACCEL (30);
8803 case 40: return GET_ACCEL (40);
8804 case 50: return GET_ACCEL (50);
8805 case 60: return GET_ACCEL (60);
8806 case 100: return GET_ACCEL (100);
8807 case 101: return GET_ACCEL (101);
8808 case 110: return GET_ACCEL (110);
8809 case 111: return GET_ACCEL (111);
8810 case 112: return GET_ACCEL (112);
8811 case 120: return GET_ACCEL (120);
8812 case 121: return GET_ACCEL (121);
8813 case 122: return GET_ACCEL (122);
8814 case 124: return GET_ACCEL (124);
8815 case 130: return GET_ACCEL (130);
8816 case 131: return GET_ACCEL (131);
8817 case 132: return GET_ACCEL (132);
8818 case 133: return GET_ACCEL (133);
8819 case 140: return GET_ACCEL (140);
8820 case 141: return GET_ACCEL (141);
8821 case 150: return GET_ACCEL (150);
8822 case 160: return GET_ACCEL (160);
8823 case 190: return GET_ACCEL (190);
8824 case 200: return GET_ACCEL (200);
8825 case 300: return GET_ACCEL (300);
8826 case 400: return GET_ACCEL (400);
8827 case 500: return GET_ACCEL (500);
8828 case 501: return GET_ACCEL (501);
8829 case 900: return GET_ACCEL (900);
8830 case 910: return GET_ACCEL (910);
8831 case 1000: return GET_ACCEL (1000);
8832 case 1100: return GET_ACCEL (1100);
8833 case 1400: return GET_ACCEL (1400);
8834 case 1410: return GET_ACCEL (1410);
8835 case 1420: return GET_ACCEL (1420);
8836 case 1421: return GET_ACCEL (1421);
8837 case 1430: return GET_ACCEL (1430);
8838 case 1440: return GET_ACCEL (1440);
8839 case 1441: return GET_ACCEL (1441);
8840 case 1450: return GET_ACCEL (1450);
8841 case 1460: return GET_ACCEL (1460);
8842 case 1500: return GET_ACCEL (1500);
8843 case 1600: return GET_ACCEL (1600);
8844 case 1700: return GET_ACCEL (1700);
8845 case 1710: return GET_ACCEL (1710);
8846 case 1711: return GET_ACCEL (1711);
8847 case 1720: return GET_ACCEL (1720);
8848 case 1722: return GET_ACCEL (1722);
8849 case 1730: return GET_ACCEL (1730);
8850 case 1731: return GET_ACCEL (1731);
8851 case 1740: return GET_ACCEL (1740);
8852 case 1750: return GET_ACCEL (1750);
8853 case 1760: return GET_ACCEL (1760);
8854 case 1800: return GET_ACCEL (1800);
8855 case 2100: return GET_ACCEL (2100);
8856 case 2400: return GET_ACCEL (2400);
8857 case 2410: return GET_ACCEL (2410);
8858 case 2500: return GET_ACCEL (2500);
8859 case 2600: return GET_ACCEL (2600);
8860 case 2611: return GET_ACCEL (2611);
8861 case 2612: return GET_ACCEL (2612);
8862 case 2711: return GET_ACCEL (2711);
8863 case 2811: return GET_ACCEL (2811);
8864 case 3000: return GET_ACCEL (3000);
8865 case 3100: return GET_ACCEL (3100);
8866 case 3200: return GET_ACCEL (3200);
8867 case 3710: return GET_ACCEL (3710);
8868 case 3711: return GET_ACCEL (3711);
8869 case 3800: return GET_ACCEL (3800);
8870 case 4300: return GET_ACCEL (4300);
8871 case 4400: return GET_ACCEL (4400);
8872 case 4500: return GET_ACCEL (4500);
8873 case 4700: return GET_ACCEL (4700);
8874 case 4800: return GET_ACCEL (4800);
8875 case 4900: return GET_ACCEL (4900);
8876 case 5000: return GET_ACCEL (5000);
8877 case 5100: return GET_ACCEL (5100);
8878 case 5200: return GET_ACCEL (5200);
8879 case 5300: return GET_ACCEL (5300);
8880 case 5400: return GET_ACCEL (5400);
8881 case 5500: return GET_ACCEL (5500);
8882 case 5600: return GET_ACCEL (5600);
8883 case 5700: return GET_ACCEL (5700);
8884 case 5800: return GET_ACCEL (5800);
8885 case 6000: return GET_ACCEL (6000);
8886 case 6100: return GET_ACCEL (6100);
8887 case 6211: return GET_ACCEL (6211);
8888 case 6212: return GET_ACCEL (6212);
8889 case 6213: return GET_ACCEL (6213);
8890 case 6221: return GET_ACCEL (6221);
8891 case 6222: return GET_ACCEL (6222);
8892 case 6223: return GET_ACCEL (6223);
8893 case 6231: return GET_ACCEL (6231);
8894 case 6232: return GET_ACCEL (6232);
8895 case 6233: return GET_ACCEL (6233);
8896 case 6241: return GET_ACCEL (6241);
8897 case 6242: return GET_ACCEL (6242);
8898 case 6243: return GET_ACCEL (6243);
8899 case 6300: return GET_ACCEL (6300);
8900 case 6400: return GET_ACCEL (6400);
8901 case 6500: return GET_ACCEL (6500);
8902 case 6600: return GET_ACCEL (6600);
8903 case 6700: return GET_ACCEL (6700);
8904 case 6800: return GET_ACCEL (6800);
8905 case 6900: return GET_ACCEL (6900);
8906 case 7100: return GET_ACCEL (7100);
8907 case 7200: return GET_ACCEL (7200);
8908 case 7300: return GET_ACCEL (7300);
8909 case 7400: return GET_ACCEL (7400);
8910 case 7500: return GET_ACCEL (7500);
8911 case 7600: return GET_ACCEL (7600);
8912 case 7700: return GET_ACCEL (7700);
8913 case 7800: return GET_ACCEL (7800);
8914 case 7900: return GET_ACCEL (7900);
8915 case 8000: return GET_ACCEL (8000);
8916 case 8100: return GET_ACCEL (8100);
8917 case 8200: return GET_ACCEL (8200);
8918 case 8300: return GET_ACCEL (8300);
8919 case 8400: return GET_ACCEL (8400);
8920 case 8500: return GET_ACCEL (8500);
8921 case 8600: return GET_ACCEL (8600);
8922 case 8700: return GET_ACCEL (8700);
8923 case 8800: return GET_ACCEL (8800);
8924 case 8900: return GET_ACCEL (8900);
8925 case 9000: return GET_ACCEL (9000);
8926 case 9100: return GET_ACCEL (9100);
8927 case 9200: return GET_ACCEL (9200);
8928 case 9300: return GET_ACCEL (9300);
8929 case 9400: return GET_ACCEL (9400);
8930 case 9500: return GET_ACCEL (9500);
8931 case 9600: return GET_ACCEL (9600);
8932 case 9700: return GET_ACCEL (9700);
8933 case 9710: return GET_ACCEL (9710);
8934 case 9720: return GET_ACCEL (9720);
8935 case 9800: return GET_ACCEL (9800);
8936 case 9810: return GET_ACCEL (9810);
8937 case 9820: return GET_ACCEL (9820);
8938 case 9900: return GET_ACCEL (9900);
8939 case 10000: return GET_ACCEL (10000);
8940 case 10100: return GET_ACCEL (10100);
8941 case 10200: return GET_ACCEL (10200);
8942 case 10300: return GET_ACCEL (10300);
8943 case 10400: return GET_ACCEL (10400);
8944 case 10410: return GET_ACCEL (10410);
8945 case 10420: return GET_ACCEL (10420);
8946 case 10500: return GET_ACCEL (10500);
8947 case 10600: return GET_ACCEL (10600);
8948 case 10700: return GET_ACCEL (10700);
8949 case 10800: return GET_ACCEL (10800);
8950 case 10900: return GET_ACCEL (10900);
8951 case 11000: return GET_ACCEL (11000);
8952 case 11100: return GET_ACCEL (11100);
8953 case 11200: return GET_ACCEL (11200);
8954 case 11300: return GET_ACCEL (11300);
8955 case 11400: return GET_ACCEL (11400);
8956 case 11500: return GET_ACCEL (11500);
8957 case 11600: return GET_ACCEL (11600);
8958 case 11700: return GET_ACCEL (11700);
8959 case 11800: return GET_ACCEL (11800);
8960 case 11900: return GET_ACCEL (11900);
8961 case 12000: return GET_ACCEL (12000);
8962 case 12100: return GET_ACCEL (12100);
8963 case 12200: return GET_ACCEL (12200);
8964 case 12300: return GET_ACCEL (12300);
8965 case 12400: return GET_ACCEL (12400);
8966 case 12500: return GET_ACCEL (12500);
8967 case 12600: return GET_ACCEL (12600);
8968 case 12700: return GET_ACCEL (12700);
8969 case 12800: return GET_ACCEL (12800);
8975 uint
set_gpu_loops (uint hash_mode
)
8979 case 0: return GET_LOOPS (0);
8980 case 10: return GET_LOOPS (10);
8981 case 11: return GET_LOOPS (11);
8982 case 12: return GET_LOOPS (12);
8983 case 20: return GET_LOOPS (20);
8984 case 21: return GET_LOOPS (21);
8985 case 22: return GET_LOOPS (22);
8986 case 23: return GET_LOOPS (23);
8987 case 30: return GET_LOOPS (30);
8988 case 40: return GET_LOOPS (40);
8989 case 50: return GET_LOOPS (50);
8990 case 60: return GET_LOOPS (60);
8991 case 100: return GET_LOOPS (100);
8992 case 101: return GET_LOOPS (101);
8993 case 110: return GET_LOOPS (110);
8994 case 111: return GET_LOOPS (111);
8995 case 112: return GET_LOOPS (112);
8996 case 120: return GET_LOOPS (120);
8997 case 121: return GET_LOOPS (121);
8998 case 122: return GET_LOOPS (122);
8999 case 124: return GET_LOOPS (124);
9000 case 130: return GET_LOOPS (130);
9001 case 131: return GET_LOOPS (131);
9002 case 132: return GET_LOOPS (132);
9003 case 133: return GET_LOOPS (133);
9004 case 140: return GET_LOOPS (140);
9005 case 141: return GET_LOOPS (141);
9006 case 150: return GET_LOOPS (150);
9007 case 160: return GET_LOOPS (160);
9008 case 190: return GET_LOOPS (190);
9009 case 200: return GET_LOOPS (200);
9010 case 300: return GET_LOOPS (300);
9011 case 400: return GET_LOOPS (400);
9012 case 500: return GET_LOOPS (500);
9013 case 501: return GET_LOOPS (501);
9014 case 900: return GET_LOOPS (900);
9015 case 910: return GET_LOOPS (910);
9016 case 1000: return GET_LOOPS (1000);
9017 case 1100: return GET_LOOPS (1100);
9018 case 1400: return GET_LOOPS (1400);
9019 case 1410: return GET_LOOPS (1410);
9020 case 1420: return GET_LOOPS (1420);
9021 case 1421: return GET_LOOPS (1421);
9022 case 1430: return GET_LOOPS (1430);
9023 case 1440: return GET_LOOPS (1440);
9024 case 1441: return GET_LOOPS (1441);
9025 case 1450: return GET_LOOPS (1450);
9026 case 1460: return GET_LOOPS (1460);
9027 case 1500: return GET_LOOPS (1500);
9028 case 1600: return GET_LOOPS (1600);
9029 case 1700: return GET_LOOPS (1700);
9030 case 1710: return GET_LOOPS (1710);
9031 case 1711: return GET_LOOPS (1711);
9032 case 1720: return GET_LOOPS (1720);
9033 case 1722: return GET_LOOPS (1722);
9034 case 1730: return GET_LOOPS (1730);
9035 case 1731: return GET_LOOPS (1731);
9036 case 1740: return GET_LOOPS (1740);
9037 case 1750: return GET_LOOPS (1750);
9038 case 1760: return GET_LOOPS (1760);
9039 case 1800: return GET_LOOPS (1800);
9040 case 2100: return GET_LOOPS (2100);
9041 case 2400: return GET_LOOPS (2400);
9042 case 2410: return GET_LOOPS (2410);
9043 case 2500: return GET_LOOPS (2500);
9044 case 2600: return GET_LOOPS (2600);
9045 case 2611: return GET_LOOPS (2611);
9046 case 2612: return GET_LOOPS (2612);
9047 case 2711: return GET_LOOPS (2711);
9048 case 2811: return GET_LOOPS (2811);
9049 case 3000: return GET_LOOPS (3000);
9050 case 3100: return GET_LOOPS (3100);
9051 case 3200: return GET_LOOPS (3200);
9052 case 3710: return GET_LOOPS (3710);
9053 case 3711: return GET_LOOPS (3711);
9054 case 3800: return GET_LOOPS (3800);
9055 case 4300: return GET_LOOPS (4300);
9056 case 4400: return GET_LOOPS (4400);
9057 case 4500: return GET_LOOPS (4500);
9058 case 4700: return GET_LOOPS (4700);
9059 case 4800: return GET_LOOPS (4800);
9060 case 4900: return GET_LOOPS (4900);
9061 case 5000: return GET_LOOPS (5000);
9062 case 5100: return GET_LOOPS (5100);
9063 case 5200: return GET_LOOPS (5200);
9064 case 5300: return GET_LOOPS (5300);
9065 case 5400: return GET_LOOPS (5400);
9066 case 5500: return GET_LOOPS (5500);
9067 case 5600: return GET_LOOPS (5600);
9068 case 5700: return GET_LOOPS (5700);
9069 case 5800: return GET_LOOPS (5800);
9070 case 6000: return GET_LOOPS (6000);
9071 case 6100: return GET_LOOPS (6100);
9072 case 6211: return GET_LOOPS (6211);
9073 case 6212: return GET_LOOPS (6212);
9074 case 6213: return GET_LOOPS (6213);
9075 case 6221: return GET_LOOPS (6221);
9076 case 6222: return GET_LOOPS (6222);
9077 case 6223: return GET_LOOPS (6223);
9078 case 6231: return GET_LOOPS (6231);
9079 case 6232: return GET_LOOPS (6232);
9080 case 6233: return GET_LOOPS (6233);
9081 case 6241: return GET_LOOPS (6241);
9082 case 6242: return GET_LOOPS (6242);
9083 case 6243: return GET_LOOPS (6243);
9084 case 6300: return GET_LOOPS (6300);
9085 case 6400: return GET_LOOPS (6400);
9086 case 6500: return GET_LOOPS (6500);
9087 case 6600: return GET_LOOPS (6600);
9088 case 6700: return GET_LOOPS (6700);
9089 case 6800: return GET_LOOPS (6800);
9090 case 6900: return GET_LOOPS (6900);
9091 case 7100: return GET_LOOPS (7100);
9092 case 7200: return GET_LOOPS (7200);
9093 case 7300: return GET_LOOPS (7300);
9094 case 7400: return GET_LOOPS (7400);
9095 case 7500: return GET_LOOPS (7500);
9096 case 7600: return GET_LOOPS (7600);
9097 case 7700: return GET_LOOPS (7700);
9098 case 7800: return GET_LOOPS (7800);
9099 case 7900: return GET_LOOPS (7900);
9100 case 8000: return GET_LOOPS (8000);
9101 case 8100: return GET_LOOPS (8100);
9102 case 8200: return GET_LOOPS (8200);
9103 case 8300: return GET_LOOPS (8300);
9104 case 8400: return GET_LOOPS (8400);
9105 case 8500: return GET_LOOPS (8500);
9106 case 8600: return GET_LOOPS (8600);
9107 case 8700: return GET_LOOPS (8700);
9108 case 8800: return GET_LOOPS (8800);
9109 case 8900: return GET_LOOPS (8900);
9110 case 9000: return GET_LOOPS (9000);
9111 case 9100: return GET_LOOPS (9100);
9112 case 9200: return GET_LOOPS (9200);
9113 case 9300: return GET_LOOPS (9300);
9114 case 9400: return GET_LOOPS (9400);
9115 case 9500: return GET_LOOPS (9500);
9116 case 9600: return GET_LOOPS (9600);
9117 case 9700: return GET_LOOPS (9700);
9118 case 9710: return GET_LOOPS (9710);
9119 case 9720: return GET_LOOPS (9720);
9120 case 9800: return GET_LOOPS (9800);
9121 case 9810: return GET_LOOPS (9810);
9122 case 9820: return GET_LOOPS (9820);
9123 case 9900: return GET_LOOPS (9900);
9124 case 10000: return GET_LOOPS (10000);
9125 case 10100: return GET_LOOPS (10100);
9126 case 10200: return GET_LOOPS (10200);
9127 case 10300: return GET_LOOPS (10300);
9128 case 10400: return GET_LOOPS (10400);
9129 case 10410: return GET_LOOPS (10410);
9130 case 10420: return GET_LOOPS (10420);
9131 case 10500: return GET_LOOPS (10500);
9132 case 10600: return GET_LOOPS (10600);
9133 case 10700: return GET_LOOPS (10700);
9134 case 10800: return GET_LOOPS (10800);
9135 case 10900: return GET_LOOPS (10900);
9136 case 11000: return GET_LOOPS (11000);
9137 case 11100: return GET_LOOPS (11100);
9138 case 11200: return GET_LOOPS (11200);
9139 case 11300: return GET_LOOPS (11300);
9140 case 11400: return GET_LOOPS (11400);
9141 case 11500: return GET_LOOPS (11500);
9142 case 11600: return GET_LOOPS (11600);
9143 case 11700: return GET_LOOPS (11700);
9144 case 11800: return GET_LOOPS (11800);
9145 case 11900: return GET_LOOPS (11900);
9146 case 12000: return GET_LOOPS (12000);
9147 case 12100: return GET_LOOPS (12100);
9148 case 12200: return GET_LOOPS (12200);
9149 case 12300: return GET_LOOPS (12300);
9150 case 12400: return GET_LOOPS (12400);
9151 case 12500: return GET_LOOPS (12500);
9152 case 12600: return GET_LOOPS (12600);
9153 case 12700: return GET_LOOPS (12700);
9154 case 12800: return GET_LOOPS (12800);
9164 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9168 if (salt_len
> sizeof(tmp
))
9173 memset (tmp
, 0, sizeof (tmp
));
9174 memcpy (tmp
, in
, salt_len
);
9176 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9178 if ((salt_len
% 2) == 0)
9180 uint new_salt_len
= salt_len
/ 2;
9182 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9184 char p0
= tmp
[j
+ 0];
9185 char p1
= tmp
[j
+ 1];
9187 tmp
[i
] = hex_convert (p1
) << 0;
9188 tmp
[i
] |= hex_convert (p0
) << 4;
9191 salt_len
= new_salt_len
;
9198 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9200 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9203 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9205 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9209 uint
*tmp_uint
= (uint
*) tmp
;
9211 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9212 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9213 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9214 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9215 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9216 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9217 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9218 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9219 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9220 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9222 salt_len
= salt_len
* 2;
9230 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9232 lowercase (tmp
, salt_len
);
9235 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9237 uppercase (tmp
, salt_len
);
9240 uint len
= salt_len
;
9242 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9247 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9252 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9254 uint
*tmp_uint
= (uint
*) tmp
;
9260 for (uint i
= 0; i
< max
; i
++)
9262 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9265 // Important: we may need to increase the length of memcpy since
9266 // we don't want to "loose" some swapped bytes (could happen if
9267 // they do not perfectly fit in the 4-byte blocks)
9268 // Memcpy does always copy the bytes in the BE order, but since
9269 // we swapped them, some important bytes could be in positions
9270 // we normally skip with the original len
9272 if (len
% 4) len
+= 4 - (len
% 4);
9275 memcpy (out
, tmp
, len
);
9280 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9282 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9284 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9286 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9288 salt_t
*salt
= hash_buf
->salt
;
9290 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9292 char *iter_pos
= input_buf
+ 4;
9294 salt
->salt_iter
= 1 << atoi (iter_pos
);
9296 char *salt_pos
= strchr (iter_pos
, '$');
9298 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9304 salt
->salt_len
= salt_len
;
9308 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9310 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9312 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9314 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9316 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9317 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9318 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9319 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9321 char *hash_pos
= salt_pos
+ 22;
9323 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9325 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9327 memcpy (digest
, tmp_buf
, 24);
9329 digest
[0] = byte_swap_32 (digest
[0]);
9330 digest
[1] = byte_swap_32 (digest
[1]);
9331 digest
[2] = byte_swap_32 (digest
[2]);
9332 digest
[3] = byte_swap_32 (digest
[3]);
9333 digest
[4] = byte_swap_32 (digest
[4]);
9334 digest
[5] = byte_swap_32 (digest
[5]);
9336 digest
[5] &= ~0xff; // its just 23 not 24 !
9341 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9343 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9345 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9349 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9351 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9353 memcpy (digest
, tmp_buf
, 32);
9355 digest
[0] = byte_swap_32 (digest
[0]);
9356 digest
[1] = byte_swap_32 (digest
[1]);
9357 digest
[2] = byte_swap_32 (digest
[2]);
9358 digest
[3] = byte_swap_32 (digest
[3]);
9359 digest
[4] = byte_swap_32 (digest
[4]);
9360 digest
[5] = byte_swap_32 (digest
[5]);
9361 digest
[6] = byte_swap_32 (digest
[6]);
9362 digest
[7] = byte_swap_32 (digest
[7]);
9364 digest
[0] -= SHA256M_A
;
9365 digest
[1] -= SHA256M_B
;
9366 digest
[2] -= SHA256M_C
;
9367 digest
[3] -= SHA256M_D
;
9368 digest
[4] -= SHA256M_E
;
9369 digest
[5] -= SHA256M_F
;
9370 digest
[6] -= SHA256M_G
;
9371 digest
[7] -= SHA256M_H
;
9376 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9378 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9380 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9382 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9383 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9385 digest
[0] = byte_swap_32 (digest
[0]);
9386 digest
[1] = byte_swap_32 (digest
[1]);
9390 IP (digest
[0], digest
[1], tt
);
9392 digest
[0] = digest
[0];
9393 digest
[1] = digest
[1];
9400 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9402 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9404 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9406 salt_t
*salt
= hash_buf
->salt
;
9408 char *hash_pos
= input_buf
+ 8;
9410 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9411 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9412 digest
[2] = hex_to_uint (&hash_pos
[16]);
9413 digest
[3] = hex_to_uint (&hash_pos
[24]);
9414 digest
[4] = hex_to_uint (&hash_pos
[32]);
9416 digest
[0] -= SHA1M_A
;
9417 digest
[1] -= SHA1M_B
;
9418 digest
[2] -= SHA1M_C
;
9419 digest
[3] -= SHA1M_D
;
9420 digest
[4] -= SHA1M_E
;
9424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9426 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9428 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9430 salt
->salt_len
= salt_len
;
9435 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9437 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9439 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9441 salt_t
*salt
= hash_buf
->salt
;
9443 char *hash_pos
= input_buf
+ 8;
9445 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9446 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9447 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9448 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9449 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9450 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9451 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9452 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9454 digest
[0] -= SHA512M_A
;
9455 digest
[1] -= SHA512M_B
;
9456 digest
[2] -= SHA512M_C
;
9457 digest
[3] -= SHA512M_D
;
9458 digest
[4] -= SHA512M_E
;
9459 digest
[5] -= SHA512M_F
;
9460 digest
[6] -= SHA512M_G
;
9461 digest
[7] -= SHA512M_H
;
9465 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9467 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9469 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9471 salt
->salt_len
= salt_len
;
9476 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9478 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9480 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9484 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9487 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9489 salt_t
*salt
= hash_buf
->salt
;
9491 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9492 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9493 digest
[2] = hex_to_uint (&input_buf
[16]);
9494 digest
[3] = hex_to_uint (&input_buf
[24]);
9496 digest
[0] = byte_swap_32 (digest
[0]);
9497 digest
[1] = byte_swap_32 (digest
[1]);
9498 digest
[2] = byte_swap_32 (digest
[2]);
9499 digest
[3] = byte_swap_32 (digest
[3]);
9501 digest
[0] -= MD5M_A
;
9502 digest
[1] -= MD5M_B
;
9503 digest
[2] -= MD5M_C
;
9504 digest
[3] -= MD5M_D
;
9506 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9508 uint salt_len
= input_len
- 32 - 1;
9510 char *salt_buf
= input_buf
+ 32 + 1;
9512 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9514 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9516 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9518 salt
->salt_len
= salt_len
;
9523 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9525 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9527 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9531 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9536 char clean_input_buf
[32];
9538 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9539 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9541 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9545 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9551 clean_input_buf
[k
] = input_buf
[i
];
9559 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9561 salt_t
*salt
= hash_buf
->salt
;
9563 char a
, b
, c
, d
, e
, f
;
9565 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9566 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9567 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9568 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9569 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9570 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9572 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9573 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9575 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9576 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9577 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9578 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9579 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9580 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9582 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9583 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9585 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9586 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9587 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9588 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9589 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9590 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9592 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9593 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9595 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9596 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9597 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9598 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9599 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9600 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9602 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9603 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9605 digest
[0] = byte_swap_32 (digest
[0]);
9606 digest
[1] = byte_swap_32 (digest
[1]);
9607 digest
[2] = byte_swap_32 (digest
[2]);
9608 digest
[3] = byte_swap_32 (digest
[3]);
9610 digest
[0] -= MD5M_A
;
9611 digest
[1] -= MD5M_B
;
9612 digest
[2] -= MD5M_C
;
9613 digest
[3] -= MD5M_D
;
9615 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9617 uint salt_len
= input_len
- 30 - 1;
9619 char *salt_buf
= input_buf
+ 30 + 1;
9621 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9623 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9625 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9627 salt
->salt_len
= salt_len
;
9629 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9631 salt
->salt_len
+= 22;
9636 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9638 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9640 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9644 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9647 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9649 salt_t
*salt
= hash_buf
->salt
;
9651 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9652 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9653 digest
[2] = hex_to_uint (&input_buf
[16]);
9654 digest
[3] = hex_to_uint (&input_buf
[24]);
9655 digest
[4] = hex_to_uint (&input_buf
[32]);
9657 digest
[0] -= SHA1M_A
;
9658 digest
[1] -= SHA1M_B
;
9659 digest
[2] -= SHA1M_C
;
9660 digest
[3] -= SHA1M_D
;
9661 digest
[4] -= SHA1M_E
;
9663 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9665 uint salt_len
= input_len
- 40 - 1;
9667 char *salt_buf
= input_buf
+ 40 + 1;
9669 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9671 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9673 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9675 salt
->salt_len
= salt_len
;
9680 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9682 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9684 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9688 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9691 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9693 char *iter_pos
= input_buf
+ 6;
9695 salt_t
*salt
= hash_buf
->salt
;
9697 salt
->salt_iter
= atoi (iter_pos
) - 1;
9699 char *salt_pos
= strchr (iter_pos
, '#');
9701 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9705 char *digest_pos
= strchr (salt_pos
, '#');
9707 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9711 uint salt_len
= digest_pos
- salt_pos
- 1;
9713 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9715 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9716 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9717 digest
[2] = hex_to_uint (&digest_pos
[16]);
9718 digest
[3] = hex_to_uint (&digest_pos
[24]);
9720 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9722 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9724 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9726 salt
->salt_len
= salt_len
;
9731 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9733 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9735 salt_t
*salt
= hash_buf
->salt
;
9737 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9741 memcpy (&in
, input_buf
, input_len
);
9743 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9745 memcpy (digest
, in
.keymic
, 16);
9748 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9749 The phrase "Pairwise key expansion"
9750 Access Point Address (Referred to as Authenticator Address AA)
9751 Supplicant Address (referred to as Supplicant Address SA)
9752 Access Point Nonce (referred to as Authenticator Anonce)
9753 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9756 uint salt_len
= strlen (in
.essid
);
9758 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9760 salt
->salt_len
= salt_len
;
9762 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9764 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9766 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9768 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9770 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9771 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9775 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9776 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9779 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9781 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9782 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9786 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9787 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9790 for (int i
= 0; i
< 25; i
++)
9792 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9795 wpa
->keyver
= in
.keyver
;
9797 if (wpa
->keyver
> 255)
9799 log_info ("ATTENTION!");
9800 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9801 log_info (" This could be due to a recent aircrack-ng bug.");
9802 log_info (" The key version was automatically reset to a reasonable value.");
9805 wpa
->keyver
&= 0xff;
9808 wpa
->eapol_size
= in
.eapol_size
;
9810 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9812 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9814 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9816 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9818 if (wpa
->keyver
== 1)
9824 digest
[0] = byte_swap_32 (digest
[0]);
9825 digest
[1] = byte_swap_32 (digest
[1]);
9826 digest
[2] = byte_swap_32 (digest
[2]);
9827 digest
[3] = byte_swap_32 (digest
[3]);
9829 for (int i
= 0; i
< 64; i
++)
9831 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9835 salt
->salt_buf
[10] = digest
[1];
9836 salt
->salt_buf
[11] = digest
[2];
9841 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9843 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9845 salt_t
*salt
= hash_buf
->salt
;
9849 log_error ("Password Safe v2 container not specified");
9854 FILE *fp
= fopen (input_buf
, "rb");
9858 log_error ("%s: %s", input_buf
, strerror (errno
));
9867 uint32_t salt
[5]; // unused, but makes better valid check
9868 uint32_t iv
[2]; // unused, but makes better valid check
9874 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9878 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9880 salt
->salt_buf
[0] = buf
.random
[0];
9881 salt
->salt_buf
[1] = buf
.random
[1];
9884 salt
->salt_iter
= 1000;
9886 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9887 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9888 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9889 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9890 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9895 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9897 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9899 salt_t
*salt
= hash_buf
->salt
;
9903 log_error (".psafe3 not specified");
9908 FILE *fp
= fopen (input_buf
, "rb");
9912 log_error ("%s: %s", input_buf
, strerror (errno
));
9919 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9923 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9925 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9927 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9929 salt
->salt_iter
= in
.iterations
+ 1;
9931 salt
->salt_buf
[0] = in
.salt_buf
[0];
9932 salt
->salt_buf
[1] = in
.salt_buf
[1];
9933 salt
->salt_buf
[2] = in
.salt_buf
[2];
9934 salt
->salt_buf
[3] = in
.salt_buf
[3];
9935 salt
->salt_buf
[4] = in
.salt_buf
[4];
9936 salt
->salt_buf
[5] = in
.salt_buf
[5];
9937 salt
->salt_buf
[6] = in
.salt_buf
[6];
9938 salt
->salt_buf
[7] = in
.salt_buf
[7];
9940 salt
->salt_len
= 32;
9942 digest
[0] = in
.hash_buf
[0];
9943 digest
[1] = in
.hash_buf
[1];
9944 digest
[2] = in
.hash_buf
[2];
9945 digest
[3] = in
.hash_buf
[3];
9946 digest
[4] = in
.hash_buf
[4];
9947 digest
[5] = in
.hash_buf
[5];
9948 digest
[6] = in
.hash_buf
[6];
9949 digest
[7] = in
.hash_buf
[7];
9951 digest
[0] = byte_swap_32 (digest
[0]);
9952 digest
[1] = byte_swap_32 (digest
[1]);
9953 digest
[2] = byte_swap_32 (digest
[2]);
9954 digest
[3] = byte_swap_32 (digest
[3]);
9955 digest
[4] = byte_swap_32 (digest
[4]);
9956 digest
[5] = byte_swap_32 (digest
[5]);
9957 digest
[6] = byte_swap_32 (digest
[6]);
9958 digest
[7] = byte_swap_32 (digest
[7]);
9963 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9965 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
9967 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
9969 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9971 salt_t
*salt
= hash_buf
->salt
;
9973 char *iter_pos
= input_buf
+ 3;
9975 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
9977 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
9979 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
9981 salt
->salt_iter
= salt_iter
;
9983 char *salt_pos
= iter_pos
+ 1;
9987 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
9989 salt
->salt_len
= salt_len
;
9991 char *hash_pos
= salt_pos
+ salt_len
;
9993 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
9998 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10000 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10002 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10004 salt_t
*salt
= hash_buf
->salt
;
10006 char *salt_pos
= input_buf
+ 3;
10008 uint iterations_len
= 0;
10010 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10014 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10016 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10017 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10021 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10025 iterations_len
+= 8;
10029 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10032 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10034 char *hash_pos
= strchr (salt_pos
, '$');
10036 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10038 uint salt_len
= hash_pos
- salt_pos
;
10040 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10042 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10044 salt
->salt_len
= salt_len
;
10048 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10050 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10052 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10054 return (PARSER_OK
);
10057 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10059 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10061 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10063 salt_t
*salt
= hash_buf
->salt
;
10065 char *salt_pos
= input_buf
+ 6;
10067 uint iterations_len
= 0;
10069 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10073 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10075 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10076 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10080 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10084 iterations_len
+= 8;
10088 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10091 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10093 char *hash_pos
= strchr (salt_pos
, '$');
10095 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10097 uint salt_len
= hash_pos
- salt_pos
;
10099 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10101 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10103 salt
->salt_len
= salt_len
;
10107 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10109 return (PARSER_OK
);
10112 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10114 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10116 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10118 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10120 salt_t
*salt
= hash_buf
->salt
;
10122 char *salt_pos
= input_buf
+ 14;
10124 char *hash_pos
= strchr (salt_pos
, '*');
10126 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10130 uint salt_len
= hash_pos
- salt_pos
- 1;
10132 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10134 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10136 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10138 salt
->salt_len
= salt_len
;
10140 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10142 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10144 memcpy (digest
, tmp_buf
, 20);
10146 digest
[0] = byte_swap_32 (digest
[0]);
10147 digest
[1] = byte_swap_32 (digest
[1]);
10148 digest
[2] = byte_swap_32 (digest
[2]);
10149 digest
[3] = byte_swap_32 (digest
[3]);
10150 digest
[4] = byte_swap_32 (digest
[4]);
10152 digest
[0] -= SHA1M_A
;
10153 digest
[1] -= SHA1M_B
;
10154 digest
[2] -= SHA1M_C
;
10155 digest
[3] -= SHA1M_D
;
10156 digest
[4] -= SHA1M_E
;
10158 return (PARSER_OK
);
10161 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10163 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10165 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10167 if (c12
& 3) return (PARSER_HASH_VALUE
);
10169 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10171 salt_t
*salt
= hash_buf
->salt
;
10173 // for ascii_digest
10174 salt
->salt_sign
[0] = input_buf
[0];
10175 salt
->salt_sign
[1] = input_buf
[1];
10177 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10178 | itoa64_to_int (input_buf
[1]) << 6;
10180 salt
->salt_len
= 2;
10184 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10186 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10188 memcpy (digest
, tmp_buf
, 8);
10192 IP (digest
[0], digest
[1], tt
);
10197 return (PARSER_OK
);
10200 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10202 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10204 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10206 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10207 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10208 digest
[2] = hex_to_uint (&input_buf
[16]);
10209 digest
[3] = hex_to_uint (&input_buf
[24]);
10211 digest
[0] = byte_swap_32 (digest
[0]);
10212 digest
[1] = byte_swap_32 (digest
[1]);
10213 digest
[2] = byte_swap_32 (digest
[2]);
10214 digest
[3] = byte_swap_32 (digest
[3]);
10216 digest
[0] -= MD4M_A
;
10217 digest
[1] -= MD4M_B
;
10218 digest
[2] -= MD4M_C
;
10219 digest
[3] -= MD4M_D
;
10221 return (PARSER_OK
);
10224 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10226 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10228 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10232 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10235 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10237 salt_t
*salt
= hash_buf
->salt
;
10239 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10240 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10241 digest
[2] = hex_to_uint (&input_buf
[16]);
10242 digest
[3] = hex_to_uint (&input_buf
[24]);
10244 digest
[0] = byte_swap_32 (digest
[0]);
10245 digest
[1] = byte_swap_32 (digest
[1]);
10246 digest
[2] = byte_swap_32 (digest
[2]);
10247 digest
[3] = byte_swap_32 (digest
[3]);
10249 digest
[0] -= MD4M_A
;
10250 digest
[1] -= MD4M_B
;
10251 digest
[2] -= MD4M_C
;
10252 digest
[3] -= MD4M_D
;
10254 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10256 uint salt_len
= input_len
- 32 - 1;
10258 char *salt_buf
= input_buf
+ 32 + 1;
10260 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10262 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10264 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10266 salt
->salt_len
= salt_len
;
10268 return (PARSER_OK
);
10271 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10273 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10275 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10277 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10278 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10279 digest
[2] = hex_to_uint (&input_buf
[16]);
10280 digest
[3] = hex_to_uint (&input_buf
[24]);
10282 digest
[0] = byte_swap_32 (digest
[0]);
10283 digest
[1] = byte_swap_32 (digest
[1]);
10284 digest
[2] = byte_swap_32 (digest
[2]);
10285 digest
[3] = byte_swap_32 (digest
[3]);
10287 digest
[0] -= MD5M_A
;
10288 digest
[1] -= MD5M_B
;
10289 digest
[2] -= MD5M_C
;
10290 digest
[3] -= MD5M_D
;
10292 return (PARSER_OK
);
10295 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10297 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10299 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10301 digest
[0] = hex_to_uint (&input_buf
[0]);
10302 digest
[1] = hex_to_uint (&input_buf
[8]);
10306 digest
[0] = byte_swap_32 (digest
[0]);
10307 digest
[1] = byte_swap_32 (digest
[1]);
10309 return (PARSER_OK
);
10312 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10314 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10316 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10320 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10323 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10325 salt_t
*salt
= hash_buf
->salt
;
10327 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10328 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10329 digest
[2] = hex_to_uint (&input_buf
[16]);
10330 digest
[3] = hex_to_uint (&input_buf
[24]);
10332 digest
[0] = byte_swap_32 (digest
[0]);
10333 digest
[1] = byte_swap_32 (digest
[1]);
10334 digest
[2] = byte_swap_32 (digest
[2]);
10335 digest
[3] = byte_swap_32 (digest
[3]);
10337 digest
[0] -= MD5M_A
;
10338 digest
[1] -= MD5M_B
;
10339 digest
[2] -= MD5M_C
;
10340 digest
[3] -= MD5M_D
;
10342 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10344 uint salt_len
= input_len
- 32 - 1;
10346 char *salt_buf
= input_buf
+ 32 + 1;
10348 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10350 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10352 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10354 salt
->salt_len
= salt_len
;
10356 return (PARSER_OK
);
10359 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10361 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10363 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10365 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10366 | itoa64_to_int (input_buf
[ 1]) << 6
10367 | itoa64_to_int (input_buf
[ 2]) << 12
10368 | itoa64_to_int (input_buf
[ 3]) << 18;
10369 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10370 | itoa64_to_int (input_buf
[ 5]) << 6
10371 | itoa64_to_int (input_buf
[ 6]) << 12
10372 | itoa64_to_int (input_buf
[ 7]) << 18;
10373 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10374 | itoa64_to_int (input_buf
[ 9]) << 6
10375 | itoa64_to_int (input_buf
[10]) << 12
10376 | itoa64_to_int (input_buf
[11]) << 18;
10377 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10378 | itoa64_to_int (input_buf
[13]) << 6
10379 | itoa64_to_int (input_buf
[14]) << 12
10380 | itoa64_to_int (input_buf
[15]) << 18;
10382 digest
[0] -= MD5M_A
;
10383 digest
[1] -= MD5M_B
;
10384 digest
[2] -= MD5M_C
;
10385 digest
[3] -= MD5M_D
;
10387 digest
[0] &= 0x00ffffff;
10388 digest
[1] &= 0x00ffffff;
10389 digest
[2] &= 0x00ffffff;
10390 digest
[3] &= 0x00ffffff;
10392 return (PARSER_OK
);
10395 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10397 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10399 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10403 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10406 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10408 salt_t
*salt
= hash_buf
->salt
;
10410 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10411 | itoa64_to_int (input_buf
[ 1]) << 6
10412 | itoa64_to_int (input_buf
[ 2]) << 12
10413 | itoa64_to_int (input_buf
[ 3]) << 18;
10414 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10415 | itoa64_to_int (input_buf
[ 5]) << 6
10416 | itoa64_to_int (input_buf
[ 6]) << 12
10417 | itoa64_to_int (input_buf
[ 7]) << 18;
10418 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10419 | itoa64_to_int (input_buf
[ 9]) << 6
10420 | itoa64_to_int (input_buf
[10]) << 12
10421 | itoa64_to_int (input_buf
[11]) << 18;
10422 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10423 | itoa64_to_int (input_buf
[13]) << 6
10424 | itoa64_to_int (input_buf
[14]) << 12
10425 | itoa64_to_int (input_buf
[15]) << 18;
10427 digest
[0] -= MD5M_A
;
10428 digest
[1] -= MD5M_B
;
10429 digest
[2] -= MD5M_C
;
10430 digest
[3] -= MD5M_D
;
10432 digest
[0] &= 0x00ffffff;
10433 digest
[1] &= 0x00ffffff;
10434 digest
[2] &= 0x00ffffff;
10435 digest
[3] &= 0x00ffffff;
10437 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10439 uint salt_len
= input_len
- 16 - 1;
10441 char *salt_buf
= input_buf
+ 16 + 1;
10443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10449 salt
->salt_len
= salt_len
;
10451 return (PARSER_OK
);
10454 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10456 key
[0] = (nthash
[0] >> 0);
10457 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10458 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10459 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10460 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10461 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10462 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10463 key
[7] = (nthash
[6] << 1);
10475 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10477 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10479 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10481 salt_t
*salt
= hash_buf
->salt
;
10483 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10489 char *user_pos
= input_buf
;
10491 char *unused_pos
= strchr (user_pos
, ':');
10493 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10495 uint user_len
= unused_pos
- user_pos
;
10497 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10501 char *domain_pos
= strchr (unused_pos
, ':');
10503 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10505 uint unused_len
= domain_pos
- unused_pos
;
10507 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10511 char *srvchall_pos
= strchr (domain_pos
, ':');
10513 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10515 uint domain_len
= srvchall_pos
- domain_pos
;
10517 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10521 char *hash_pos
= strchr (srvchall_pos
, ':');
10523 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10525 uint srvchall_len
= hash_pos
- srvchall_pos
;
10527 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10531 char *clichall_pos
= strchr (hash_pos
, ':');
10533 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10535 uint hash_len
= clichall_pos
- hash_pos
;
10537 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10541 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10543 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10546 * store some data for later use
10549 netntlm
->user_len
= user_len
* 2;
10550 netntlm
->domain_len
= domain_len
* 2;
10551 netntlm
->srvchall_len
= srvchall_len
/ 2;
10552 netntlm
->clichall_len
= clichall_len
/ 2;
10554 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10555 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10558 * handle username and domainname
10561 for (uint i
= 0; i
< user_len
; i
++)
10563 *userdomain_ptr
++ = user_pos
[i
];
10564 *userdomain_ptr
++ = 0;
10567 for (uint i
= 0; i
< domain_len
; i
++)
10569 *userdomain_ptr
++ = domain_pos
[i
];
10570 *userdomain_ptr
++ = 0;
10574 * handle server challenge encoding
10577 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10579 const char p0
= srvchall_pos
[i
+ 0];
10580 const char p1
= srvchall_pos
[i
+ 1];
10582 *chall_ptr
++ = hex_convert (p1
) << 0
10583 | hex_convert (p0
) << 4;
10587 * handle client challenge encoding
10590 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10592 const char p0
= clichall_pos
[i
+ 0];
10593 const char p1
= clichall_pos
[i
+ 1];
10595 *chall_ptr
++ = hex_convert (p1
) << 0
10596 | hex_convert (p0
) << 4;
10603 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10605 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10607 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10609 salt
->salt_len
= salt_len
;
10611 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10612 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10613 digest
[2] = hex_to_uint (&hash_pos
[16]);
10614 digest
[3] = hex_to_uint (&hash_pos
[24]);
10616 digest
[0] = byte_swap_32 (digest
[0]);
10617 digest
[1] = byte_swap_32 (digest
[1]);
10618 digest
[2] = byte_swap_32 (digest
[2]);
10619 digest
[3] = byte_swap_32 (digest
[3]);
10621 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10623 uint digest_tmp
[2];
10625 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10626 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10628 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10629 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10631 /* special case 2: ESS */
10633 if (srvchall_len
== 48)
10635 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10639 w
[ 0] = netntlm
->chall_buf
[6];
10640 w
[ 1] = netntlm
->chall_buf
[7];
10641 w
[ 2] = netntlm
->chall_buf
[0];
10642 w
[ 3] = netntlm
->chall_buf
[1];
10665 salt
->salt_buf
[0] = dgst
[0];
10666 salt
->salt_buf
[1] = dgst
[1];
10670 /* precompute netntlmv1 exploit start */
10672 for (uint i
= 0; i
< 0x10000; i
++)
10674 uint key_md4
[2] = { i
, 0 };
10675 uint key_des
[2] = { 0, 0 };
10677 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10682 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10684 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10686 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10688 if (data3
[0] != digest_tmp
[0]) continue;
10689 if (data3
[1] != digest_tmp
[1]) continue;
10691 salt
->salt_buf
[2] = i
;
10693 salt
->salt_len
= 24;
10698 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10699 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10701 /* precompute netntlmv1 exploit stop */
10705 IP (digest
[0], digest
[1], tt
);
10706 IP (digest
[2], digest
[3], tt
);
10708 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10709 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10710 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10711 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10713 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10715 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10716 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10718 return (PARSER_OK
);
10721 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10723 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10725 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10727 salt_t
*salt
= hash_buf
->salt
;
10729 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10735 char *user_pos
= input_buf
;
10737 char *unused_pos
= strchr (user_pos
, ':');
10739 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10741 uint user_len
= unused_pos
- user_pos
;
10743 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10747 char *domain_pos
= strchr (unused_pos
, ':');
10749 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10751 uint unused_len
= domain_pos
- unused_pos
;
10753 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10757 char *srvchall_pos
= strchr (domain_pos
, ':');
10759 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10761 uint domain_len
= srvchall_pos
- domain_pos
;
10763 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10767 char *hash_pos
= strchr (srvchall_pos
, ':');
10769 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10771 uint srvchall_len
= hash_pos
- srvchall_pos
;
10773 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10777 char *clichall_pos
= strchr (hash_pos
, ':');
10779 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10781 uint hash_len
= clichall_pos
- hash_pos
;
10783 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10787 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10789 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10791 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10794 * store some data for later use
10797 netntlm
->user_len
= user_len
* 2;
10798 netntlm
->domain_len
= domain_len
* 2;
10799 netntlm
->srvchall_len
= srvchall_len
/ 2;
10800 netntlm
->clichall_len
= clichall_len
/ 2;
10802 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10803 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10806 * handle username and domainname
10809 for (uint i
= 0; i
< user_len
; i
++)
10811 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10812 *userdomain_ptr
++ = 0;
10815 for (uint i
= 0; i
< domain_len
; i
++)
10817 *userdomain_ptr
++ = domain_pos
[i
];
10818 *userdomain_ptr
++ = 0;
10821 *userdomain_ptr
++ = 0x80;
10824 * handle server challenge encoding
10827 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10829 const char p0
= srvchall_pos
[i
+ 0];
10830 const char p1
= srvchall_pos
[i
+ 1];
10832 *chall_ptr
++ = hex_convert (p1
) << 0
10833 | hex_convert (p0
) << 4;
10837 * handle client challenge encoding
10840 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10842 const char p0
= clichall_pos
[i
+ 0];
10843 const char p1
= clichall_pos
[i
+ 1];
10845 *chall_ptr
++ = hex_convert (p1
) << 0
10846 | hex_convert (p0
) << 4;
10849 *chall_ptr
++ = 0x80;
10852 * handle hash itself
10855 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10856 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10857 digest
[2] = hex_to_uint (&hash_pos
[16]);
10858 digest
[3] = hex_to_uint (&hash_pos
[24]);
10860 digest
[0] = byte_swap_32 (digest
[0]);
10861 digest
[1] = byte_swap_32 (digest
[1]);
10862 digest
[2] = byte_swap_32 (digest
[2]);
10863 digest
[3] = byte_swap_32 (digest
[3]);
10866 * reuse challange data as salt_buf, its the buffer that is most likely unique
10869 salt
->salt_buf
[0] = 0;
10870 salt
->salt_buf
[1] = 0;
10871 salt
->salt_buf
[2] = 0;
10872 salt
->salt_buf
[3] = 0;
10873 salt
->salt_buf
[4] = 0;
10874 salt
->salt_buf
[5] = 0;
10875 salt
->salt_buf
[6] = 0;
10876 salt
->salt_buf
[7] = 0;
10880 uptr
= (uint
*) netntlm
->userdomain_buf
;
10882 for (uint i
= 0; i
< 16; i
+= 16)
10884 md5_64 (uptr
, salt
->salt_buf
);
10887 uptr
= (uint
*) netntlm
->chall_buf
;
10889 for (uint i
= 0; i
< 256; i
+= 16)
10891 md5_64 (uptr
, salt
->salt_buf
);
10894 salt
->salt_len
= 16;
10896 return (PARSER_OK
);
10899 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10901 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10903 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10907 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10910 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10912 salt_t
*salt
= hash_buf
->salt
;
10914 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10915 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10916 digest
[2] = hex_to_uint (&input_buf
[16]);
10917 digest
[3] = hex_to_uint (&input_buf
[24]);
10919 digest
[0] = byte_swap_32 (digest
[0]);
10920 digest
[1] = byte_swap_32 (digest
[1]);
10921 digest
[2] = byte_swap_32 (digest
[2]);
10922 digest
[3] = byte_swap_32 (digest
[3]);
10924 digest
[0] -= MD5M_A
;
10925 digest
[1] -= MD5M_B
;
10926 digest
[2] -= MD5M_C
;
10927 digest
[3] -= MD5M_D
;
10929 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10931 uint salt_len
= input_len
- 32 - 1;
10933 char *salt_buf
= input_buf
+ 32 + 1;
10935 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10937 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10941 salt
->salt_len
= salt_len
;
10943 return (PARSER_OK
);
10946 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10948 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10950 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10954 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
10957 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10959 salt_t
*salt
= hash_buf
->salt
;
10961 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10962 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10963 digest
[2] = hex_to_uint (&input_buf
[16]);
10964 digest
[3] = hex_to_uint (&input_buf
[24]);
10966 digest
[0] = byte_swap_32 (digest
[0]);
10967 digest
[1] = byte_swap_32 (digest
[1]);
10968 digest
[2] = byte_swap_32 (digest
[2]);
10969 digest
[3] = byte_swap_32 (digest
[3]);
10971 digest
[0] -= MD5M_A
;
10972 digest
[1] -= MD5M_B
;
10973 digest
[2] -= MD5M_C
;
10974 digest
[3] -= MD5M_D
;
10976 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10978 uint salt_len
= input_len
- 32 - 1;
10980 char *salt_buf
= input_buf
+ 32 + 1;
10982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10984 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10988 salt
->salt_len
= salt_len
;
10990 return (PARSER_OK
);
10993 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10995 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
10997 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10999 salt_t
*salt
= hash_buf
->salt
;
11001 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11002 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11003 digest
[2] = hex_to_uint (&input_buf
[16]);
11004 digest
[3] = hex_to_uint (&input_buf
[24]);
11006 digest
[0] = byte_swap_32 (digest
[0]);
11007 digest
[1] = byte_swap_32 (digest
[1]);
11008 digest
[2] = byte_swap_32 (digest
[2]);
11009 digest
[3] = byte_swap_32 (digest
[3]);
11011 digest
[0] -= MD5M_A
;
11012 digest
[1] -= MD5M_B
;
11013 digest
[2] -= MD5M_C
;
11014 digest
[3] -= MD5M_D
;
11017 * This is a virtual salt. While the algorithm is basically not salted
11018 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11019 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11022 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11024 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11026 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11028 salt
->salt_len
= salt_len
;
11030 return (PARSER_OK
);
11033 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11035 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11037 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11041 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11044 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11046 salt_t
*salt
= hash_buf
->salt
;
11048 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11049 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11050 digest
[2] = hex_to_uint (&input_buf
[16]);
11051 digest
[3] = hex_to_uint (&input_buf
[24]);
11053 digest
[0] = byte_swap_32 (digest
[0]);
11054 digest
[1] = byte_swap_32 (digest
[1]);
11055 digest
[2] = byte_swap_32 (digest
[2]);
11056 digest
[3] = byte_swap_32 (digest
[3]);
11058 digest
[0] -= MD5M_A
;
11059 digest
[1] -= MD5M_B
;
11060 digest
[2] -= MD5M_C
;
11061 digest
[3] -= MD5M_D
;
11063 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11065 uint salt_len
= input_len
- 32 - 1;
11067 char *salt_buf
= input_buf
+ 32 + 1;
11069 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11071 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11073 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11075 salt
->salt_len
= salt_len
;
11077 return (PARSER_OK
);
11080 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11082 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11084 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11088 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11091 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11093 salt_t
*salt
= hash_buf
->salt
;
11095 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11096 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11097 digest
[2] = hex_to_uint (&input_buf
[16]);
11098 digest
[3] = hex_to_uint (&input_buf
[24]);
11100 digest
[0] = byte_swap_32 (digest
[0]);
11101 digest
[1] = byte_swap_32 (digest
[1]);
11102 digest
[2] = byte_swap_32 (digest
[2]);
11103 digest
[3] = byte_swap_32 (digest
[3]);
11105 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11107 uint salt_len
= input_len
- 32 - 1;
11109 char *salt_buf
= input_buf
+ 32 + 1;
11111 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11113 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11115 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11117 salt
->salt_len
= salt_len
;
11119 return (PARSER_OK
);
11122 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11124 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11126 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11130 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11133 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11135 salt_t
*salt
= hash_buf
->salt
;
11137 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11138 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11139 digest
[2] = hex_to_uint (&input_buf
[16]);
11140 digest
[3] = hex_to_uint (&input_buf
[24]);
11142 digest
[0] = byte_swap_32 (digest
[0]);
11143 digest
[1] = byte_swap_32 (digest
[1]);
11144 digest
[2] = byte_swap_32 (digest
[2]);
11145 digest
[3] = byte_swap_32 (digest
[3]);
11147 digest
[0] -= MD4M_A
;
11148 digest
[1] -= MD4M_B
;
11149 digest
[2] -= MD4M_C
;
11150 digest
[3] -= MD4M_D
;
11152 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11154 uint salt_len
= input_len
- 32 - 1;
11156 char *salt_buf
= input_buf
+ 32 + 1;
11158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11164 salt
->salt_len
= salt_len
;
11166 return (PARSER_OK
);
11169 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11171 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11173 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11177 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11180 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11182 salt_t
*salt
= hash_buf
->salt
;
11184 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11185 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11186 digest
[2] = hex_to_uint (&input_buf
[16]);
11187 digest
[3] = hex_to_uint (&input_buf
[24]);
11189 digest
[0] = byte_swap_32 (digest
[0]);
11190 digest
[1] = byte_swap_32 (digest
[1]);
11191 digest
[2] = byte_swap_32 (digest
[2]);
11192 digest
[3] = byte_swap_32 (digest
[3]);
11194 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11196 uint salt_len
= input_len
- 32 - 1;
11198 char *salt_buf
= input_buf
+ 32 + 1;
11200 uint salt_pc_block
[16];
11202 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11204 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11206 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11208 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11210 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11212 salt_pc_block
[14] = salt_len
* 8;
11214 uint salt_pc_digest
[4];
11216 salt_pc_digest
[0] = MAGIC_A
;
11217 salt_pc_digest
[1] = MAGIC_B
;
11218 salt_pc_digest
[2] = MAGIC_C
;
11219 salt_pc_digest
[3] = MAGIC_D
;
11221 md5_64 (salt_pc_block
, salt_pc_digest
);
11223 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11224 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11225 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11226 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11228 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11230 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11232 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11234 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11235 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11236 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11237 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11239 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11241 return (PARSER_OK
);
11244 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11246 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11248 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11250 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11251 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11252 digest
[2] = hex_to_uint (&input_buf
[16]);
11253 digest
[3] = hex_to_uint (&input_buf
[24]);
11254 digest
[4] = hex_to_uint (&input_buf
[32]);
11256 digest
[0] -= SHA1M_A
;
11257 digest
[1] -= SHA1M_B
;
11258 digest
[2] -= SHA1M_C
;
11259 digest
[3] -= SHA1M_D
;
11260 digest
[4] -= SHA1M_E
;
11262 return (PARSER_OK
);
11265 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11267 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11269 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11271 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11272 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11273 digest
[2] = hex_to_uint (&input_buf
[16]);
11274 digest
[3] = hex_to_uint (&input_buf
[24]);
11275 digest
[4] = hex_to_uint (&input_buf
[32]);
11277 return (PARSER_OK
);
11280 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11282 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11284 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11288 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11291 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11293 salt_t
*salt
= hash_buf
->salt
;
11295 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11296 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11297 digest
[2] = hex_to_uint (&input_buf
[16]);
11298 digest
[3] = hex_to_uint (&input_buf
[24]);
11299 digest
[4] = hex_to_uint (&input_buf
[32]);
11301 digest
[0] -= SHA1M_A
;
11302 digest
[1] -= SHA1M_B
;
11303 digest
[2] -= SHA1M_C
;
11304 digest
[3] -= SHA1M_D
;
11305 digest
[4] -= SHA1M_E
;
11307 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11309 uint salt_len
= input_len
- 40 - 1;
11311 char *salt_buf
= input_buf
+ 40 + 1;
11313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11315 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11319 salt
->salt_len
= salt_len
;
11321 return (PARSER_OK
);
11324 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11326 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11328 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11330 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11334 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11336 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11338 memcpy (digest
, tmp_buf
, 20);
11340 digest
[0] = byte_swap_32 (digest
[0]);
11341 digest
[1] = byte_swap_32 (digest
[1]);
11342 digest
[2] = byte_swap_32 (digest
[2]);
11343 digest
[3] = byte_swap_32 (digest
[3]);
11344 digest
[4] = byte_swap_32 (digest
[4]);
11346 digest
[0] -= SHA1M_A
;
11347 digest
[1] -= SHA1M_B
;
11348 digest
[2] -= SHA1M_C
;
11349 digest
[3] -= SHA1M_D
;
11350 digest
[4] -= SHA1M_E
;
11352 return (PARSER_OK
);
11355 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11357 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11359 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11361 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11363 salt_t
*salt
= hash_buf
->salt
;
11367 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11369 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11371 memcpy (digest
, tmp_buf
, 20);
11373 salt
->salt_len
= tmp_len
- 20;
11375 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11377 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11379 char *ptr
= (char *) salt
->salt_buf
;
11381 ptr
[salt
->salt_len
] = 0x80;
11384 digest
[0] = byte_swap_32 (digest
[0]);
11385 digest
[1] = byte_swap_32 (digest
[1]);
11386 digest
[2] = byte_swap_32 (digest
[2]);
11387 digest
[3] = byte_swap_32 (digest
[3]);
11388 digest
[4] = byte_swap_32 (digest
[4]);
11390 digest
[0] -= SHA1M_A
;
11391 digest
[1] -= SHA1M_B
;
11392 digest
[2] -= SHA1M_C
;
11393 digest
[3] -= SHA1M_D
;
11394 digest
[4] -= SHA1M_E
;
11396 return (PARSER_OK
);
11399 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11401 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11403 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11405 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11407 salt_t
*salt
= hash_buf
->salt
;
11409 char *salt_buf
= input_buf
+ 6;
11413 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11415 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11417 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11419 salt
->salt_len
= salt_len
;
11421 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11423 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11424 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11425 digest
[2] = hex_to_uint (&hash_pos
[16]);
11426 digest
[3] = hex_to_uint (&hash_pos
[24]);
11427 digest
[4] = hex_to_uint (&hash_pos
[32]);
11429 digest
[0] -= SHA1M_A
;
11430 digest
[1] -= SHA1M_B
;
11431 digest
[2] -= SHA1M_C
;
11432 digest
[3] -= SHA1M_D
;
11433 digest
[4] -= SHA1M_E
;
11435 return (PARSER_OK
);
11438 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11440 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11442 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11444 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11446 salt_t
*salt
= hash_buf
->salt
;
11448 char *salt_buf
= input_buf
+ 6;
11452 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11454 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11456 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11458 salt
->salt_len
= salt_len
;
11460 char *hash_pos
= input_buf
+ 6 + 8;
11462 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11463 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11464 digest
[2] = hex_to_uint (&hash_pos
[16]);
11465 digest
[3] = hex_to_uint (&hash_pos
[24]);
11466 digest
[4] = hex_to_uint (&hash_pos
[32]);
11468 digest
[0] -= SHA1M_A
;
11469 digest
[1] -= SHA1M_B
;
11470 digest
[2] -= SHA1M_C
;
11471 digest
[3] -= SHA1M_D
;
11472 digest
[4] -= SHA1M_E
;
11474 return (PARSER_OK
);
11477 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11479 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11481 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11483 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11485 salt_t
*salt
= hash_buf
->salt
;
11487 char *salt_buf
= input_buf
+ 6;
11491 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11493 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11495 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11497 salt
->salt_len
= salt_len
;
11499 char *hash_pos
= input_buf
+ 6 + 8;
11501 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11502 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11503 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11504 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11505 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11506 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11507 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11508 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11510 digest
[0] -= SHA512M_A
;
11511 digest
[1] -= SHA512M_B
;
11512 digest
[2] -= SHA512M_C
;
11513 digest
[3] -= SHA512M_D
;
11514 digest
[4] -= SHA512M_E
;
11515 digest
[5] -= SHA512M_F
;
11516 digest
[6] -= SHA512M_G
;
11517 digest
[7] -= SHA512M_H
;
11519 return (PARSER_OK
);
11522 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11524 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11526 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11530 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11533 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11535 salt_t
*salt
= hash_buf
->salt
;
11537 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11538 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11542 digest
[0] = byte_swap_32 (digest
[0]);
11543 digest
[1] = byte_swap_32 (digest
[1]);
11545 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11547 uint salt_len
= input_len
- 16 - 1;
11549 char *salt_buf
= input_buf
+ 16 + 1;
11551 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11553 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11555 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11557 salt
->salt_len
= salt_len
;
11559 return (PARSER_OK
);
11562 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11564 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11566 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11568 salt_t
*salt
= hash_buf
->salt
;
11570 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11571 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11572 digest
[2] = hex_to_uint (&input_buf
[16]);
11573 digest
[3] = hex_to_uint (&input_buf
[24]);
11574 digest
[4] = hex_to_uint (&input_buf
[32]);
11576 digest
[0] -= SHA1M_A
;
11577 digest
[1] -= SHA1M_B
;
11578 digest
[2] -= SHA1M_C
;
11579 digest
[3] -= SHA1M_D
;
11580 digest
[4] -= SHA1M_E
;
11582 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11584 uint salt_len
= input_len
- 40 - 1;
11586 char *salt_buf
= input_buf
+ 40 + 1;
11588 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11590 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11592 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11594 salt
->salt_len
= salt_len
;
11596 return (PARSER_OK
);
11599 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11601 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11603 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11605 salt_t
*salt
= hash_buf
->salt
;
11607 char *hash_pos
= input_buf
;
11609 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11610 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11611 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11612 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11613 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11614 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11615 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11616 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11617 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11618 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11619 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11620 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11621 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11622 digest
[13] = hex_to_uint (&hash_pos
[104]);
11623 digest
[14] = hex_to_uint (&hash_pos
[112]);
11624 digest
[15] = hex_to_uint (&hash_pos
[120]);
11626 char *salt_pos
= input_buf
+ 128;
11628 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11629 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11630 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11631 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11633 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11634 salt
->salt_len
= 16;
11636 return (PARSER_OK
);
11639 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11641 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11643 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11645 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11646 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11647 digest
[2] = hex_to_uint (&input_buf
[16]);
11648 digest
[3] = hex_to_uint (&input_buf
[24]);
11649 digest
[4] = hex_to_uint (&input_buf
[32]);
11650 digest
[5] = hex_to_uint (&input_buf
[40]);
11651 digest
[6] = hex_to_uint (&input_buf
[48]);
11652 digest
[7] = hex_to_uint (&input_buf
[56]);
11654 digest
[0] -= SHA256M_A
;
11655 digest
[1] -= SHA256M_B
;
11656 digest
[2] -= SHA256M_C
;
11657 digest
[3] -= SHA256M_D
;
11658 digest
[4] -= SHA256M_E
;
11659 digest
[5] -= SHA256M_F
;
11660 digest
[6] -= SHA256M_G
;
11661 digest
[7] -= SHA256M_H
;
11663 return (PARSER_OK
);
11666 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11668 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11670 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11674 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11677 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11679 salt_t
*salt
= hash_buf
->salt
;
11681 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11682 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11683 digest
[2] = hex_to_uint (&input_buf
[16]);
11684 digest
[3] = hex_to_uint (&input_buf
[24]);
11685 digest
[4] = hex_to_uint (&input_buf
[32]);
11686 digest
[5] = hex_to_uint (&input_buf
[40]);
11687 digest
[6] = hex_to_uint (&input_buf
[48]);
11688 digest
[7] = hex_to_uint (&input_buf
[56]);
11690 digest
[0] -= SHA256M_A
;
11691 digest
[1] -= SHA256M_B
;
11692 digest
[2] -= SHA256M_C
;
11693 digest
[3] -= SHA256M_D
;
11694 digest
[4] -= SHA256M_E
;
11695 digest
[5] -= SHA256M_F
;
11696 digest
[6] -= SHA256M_G
;
11697 digest
[7] -= SHA256M_H
;
11699 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11701 uint salt_len
= input_len
- 64 - 1;
11703 char *salt_buf
= input_buf
+ 64 + 1;
11705 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11707 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11709 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11711 salt
->salt_len
= salt_len
;
11713 return (PARSER_OK
);
11716 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11718 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11720 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11722 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11723 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11724 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11725 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11726 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11727 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11731 digest
[0] -= SHA384M_A
;
11732 digest
[1] -= SHA384M_B
;
11733 digest
[2] -= SHA384M_C
;
11734 digest
[3] -= SHA384M_D
;
11735 digest
[4] -= SHA384M_E
;
11736 digest
[5] -= SHA384M_F
;
11740 return (PARSER_OK
);
11743 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11745 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11747 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11749 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11750 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11751 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11752 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11753 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11754 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11755 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11756 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11758 digest
[0] -= SHA512M_A
;
11759 digest
[1] -= SHA512M_B
;
11760 digest
[2] -= SHA512M_C
;
11761 digest
[3] -= SHA512M_D
;
11762 digest
[4] -= SHA512M_E
;
11763 digest
[5] -= SHA512M_F
;
11764 digest
[6] -= SHA512M_G
;
11765 digest
[7] -= SHA512M_H
;
11767 return (PARSER_OK
);
11770 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11772 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11774 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11778 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11781 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11783 salt_t
*salt
= hash_buf
->salt
;
11785 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11786 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11787 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11788 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11789 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11790 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11791 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11792 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11794 digest
[0] -= SHA512M_A
;
11795 digest
[1] -= SHA512M_B
;
11796 digest
[2] -= SHA512M_C
;
11797 digest
[3] -= SHA512M_D
;
11798 digest
[4] -= SHA512M_E
;
11799 digest
[5] -= SHA512M_F
;
11800 digest
[6] -= SHA512M_G
;
11801 digest
[7] -= SHA512M_H
;
11803 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11805 uint salt_len
= input_len
- 128 - 1;
11807 char *salt_buf
= input_buf
+ 128 + 1;
11809 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11811 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11813 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11815 salt
->salt_len
= salt_len
;
11817 return (PARSER_OK
);
11820 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11822 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11824 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11826 salt_t
*salt
= hash_buf
->salt
;
11828 char *salt_pos
= input_buf
+ 3;
11830 uint iterations_len
= 0;
11832 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11836 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11838 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11839 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11843 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11847 iterations_len
+= 8;
11851 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11854 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11856 char *hash_pos
= strchr (salt_pos
, '$');
11858 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11860 uint salt_len
= hash_pos
- salt_pos
;
11862 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11864 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11866 salt
->salt_len
= salt_len
;
11870 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11872 return (PARSER_OK
);
11875 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11877 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11879 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11881 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11883 salt_t
*salt
= hash_buf
->salt
;
11885 uint keccak_mdlen
= input_len
/ 2;
11887 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11889 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11891 digest
[i
] = byte_swap_64 (digest
[i
]);
11894 salt
->keccak_mdlen
= keccak_mdlen
;
11896 return (PARSER_OK
);
11899 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11901 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11903 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11905 salt_t
*salt
= hash_buf
->salt
;
11907 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11910 * Parse that strange long line
11917 in_off
[0] = strtok (input_buf
, ":");
11919 in_len
[0] = strlen (in_off
[0]);
11923 for (i
= 1; i
< 9; i
++)
11925 in_off
[i
] = strtok (NULL
, ":");
11927 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11929 in_len
[i
] = strlen (in_off
[i
]);
11934 ptr
= (char *) ikepsk
->msg_buf
;
11936 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11937 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11938 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11939 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11940 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11941 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11945 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11947 ptr
= (char *) ikepsk
->nr_buf
;
11949 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11950 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11954 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
11957 * Store to database
11962 digest
[0] = hex_to_uint (&ptr
[ 0]);
11963 digest
[1] = hex_to_uint (&ptr
[ 8]);
11964 digest
[2] = hex_to_uint (&ptr
[16]);
11965 digest
[3] = hex_to_uint (&ptr
[24]);
11967 digest
[0] = byte_swap_32 (digest
[0]);
11968 digest
[1] = byte_swap_32 (digest
[1]);
11969 digest
[2] = byte_swap_32 (digest
[2]);
11970 digest
[3] = byte_swap_32 (digest
[3]);
11972 salt
->salt_len
= 32;
11974 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
11975 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
11976 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
11977 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
11978 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
11979 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
11980 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
11981 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
11983 return (PARSER_OK
);
11986 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11988 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
11990 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11992 salt_t
*salt
= hash_buf
->salt
;
11994 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11997 * Parse that strange long line
12004 in_off
[0] = strtok (input_buf
, ":");
12006 in_len
[0] = strlen (in_off
[0]);
12010 for (i
= 1; i
< 9; i
++)
12012 in_off
[i
] = strtok (NULL
, ":");
12014 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12016 in_len
[i
] = strlen (in_off
[i
]);
12021 ptr
= (char *) ikepsk
->msg_buf
;
12023 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12024 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12025 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12026 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12027 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12028 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12032 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12034 ptr
= (char *) ikepsk
->nr_buf
;
12036 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12037 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12041 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12044 * Store to database
12049 digest
[0] = hex_to_uint (&ptr
[ 0]);
12050 digest
[1] = hex_to_uint (&ptr
[ 8]);
12051 digest
[2] = hex_to_uint (&ptr
[16]);
12052 digest
[3] = hex_to_uint (&ptr
[24]);
12053 digest
[4] = hex_to_uint (&ptr
[32]);
12055 salt
->salt_len
= 32;
12057 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12058 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12059 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12060 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12061 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12062 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12063 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12064 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12066 return (PARSER_OK
);
12069 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12071 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12073 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12075 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12076 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12077 digest
[2] = hex_to_uint (&input_buf
[16]);
12078 digest
[3] = hex_to_uint (&input_buf
[24]);
12079 digest
[4] = hex_to_uint (&input_buf
[32]);
12081 digest
[0] = byte_swap_32 (digest
[0]);
12082 digest
[1] = byte_swap_32 (digest
[1]);
12083 digest
[2] = byte_swap_32 (digest
[2]);
12084 digest
[3] = byte_swap_32 (digest
[3]);
12085 digest
[4] = byte_swap_32 (digest
[4]);
12087 return (PARSER_OK
);
12090 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12092 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12094 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12096 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12097 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12098 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12099 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12100 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12101 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12102 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12103 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12104 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12105 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12106 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12107 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12108 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12109 digest
[13] = hex_to_uint (&input_buf
[104]);
12110 digest
[14] = hex_to_uint (&input_buf
[112]);
12111 digest
[15] = hex_to_uint (&input_buf
[120]);
12113 return (PARSER_OK
);
12116 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12118 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12120 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12122 salt_t
*salt
= hash_buf
->salt
;
12124 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12125 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12126 digest
[2] = hex_to_uint (&input_buf
[16]);
12127 digest
[3] = hex_to_uint (&input_buf
[24]);
12128 digest
[4] = hex_to_uint (&input_buf
[32]);
12130 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12132 uint salt_len
= input_len
- 40 - 1;
12134 char *salt_buf
= input_buf
+ 40 + 1;
12136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12140 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12142 salt
->salt_len
= salt_len
;
12144 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12146 return (PARSER_OK
);
12149 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12151 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12153 salt_t
*salt
= hash_buf
->salt
;
12155 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12157 if (input_len
== 0)
12159 log_error ("TrueCrypt container not specified");
12164 FILE *fp
= fopen (input_buf
, "rb");
12168 log_error ("%s: %s", input_buf
, strerror (errno
));
12175 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12179 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12181 memcpy (tc
->salt_buf
, buf
, 64);
12183 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12185 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12187 salt
->salt_len
= 4;
12189 salt
->salt_iter
= 1000 - 1;
12191 digest
[0] = tc
->data_buf
[0];
12193 return (PARSER_OK
);
12196 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12198 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12200 salt_t
*salt
= hash_buf
->salt
;
12202 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12204 if (input_len
== 0)
12206 log_error ("TrueCrypt container not specified");
12211 FILE *fp
= fopen (input_buf
, "rb");
12215 log_error ("%s: %s", input_buf
, strerror (errno
));
12222 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12226 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12228 memcpy (tc
->salt_buf
, buf
, 64);
12230 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12232 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12234 salt
->salt_len
= 4;
12236 salt
->salt_iter
= 2000 - 1;
12238 digest
[0] = tc
->data_buf
[0];
12240 return (PARSER_OK
);
12243 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12245 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12247 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12249 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12251 salt_t
*salt
= hash_buf
->salt
;
12253 char *salt_pos
= input_buf
+ 6;
12255 char *hash_pos
= strchr (salt_pos
, '$');
12257 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12259 uint salt_len
= hash_pos
- salt_pos
;
12261 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12263 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12265 salt
->salt_len
= salt_len
;
12267 salt
->salt_iter
= 1000;
12271 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12273 return (PARSER_OK
);
12276 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12278 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12280 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12282 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12284 salt_t
*salt
= hash_buf
->salt
;
12286 char *iter_pos
= input_buf
+ 7;
12288 char *salt_pos
= strchr (iter_pos
, '$');
12290 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12294 char *hash_pos
= strchr (salt_pos
, '$');
12296 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12298 uint salt_len
= hash_pos
- salt_pos
;
12300 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12302 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12304 salt
->salt_len
= salt_len
;
12306 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12308 salt
->salt_sign
[0] = atoi (salt_iter
);
12310 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12314 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12316 digest
[0] = byte_swap_32 (digest
[0]);
12317 digest
[1] = byte_swap_32 (digest
[1]);
12318 digest
[2] = byte_swap_32 (digest
[2]);
12319 digest
[3] = byte_swap_32 (digest
[3]);
12320 digest
[4] = byte_swap_32 (digest
[4]);
12322 return (PARSER_OK
);
12325 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12327 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12329 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12331 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12333 salt_t
*salt
= hash_buf
->salt
;
12335 char *iter_pos
= input_buf
+ 9;
12337 char *salt_pos
= strchr (iter_pos
, '$');
12339 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12343 char *hash_pos
= strchr (salt_pos
, '$');
12345 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12347 uint salt_len
= hash_pos
- salt_pos
;
12349 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12351 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12353 salt
->salt_len
= salt_len
;
12355 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12357 salt
->salt_sign
[0] = atoi (salt_iter
);
12359 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12363 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12365 digest
[0] = byte_swap_32 (digest
[0]);
12366 digest
[1] = byte_swap_32 (digest
[1]);
12367 digest
[2] = byte_swap_32 (digest
[2]);
12368 digest
[3] = byte_swap_32 (digest
[3]);
12369 digest
[4] = byte_swap_32 (digest
[4]);
12370 digest
[5] = byte_swap_32 (digest
[5]);
12371 digest
[6] = byte_swap_32 (digest
[6]);
12372 digest
[7] = byte_swap_32 (digest
[7]);
12374 return (PARSER_OK
);
12377 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12381 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12383 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12385 salt_t
*salt
= hash_buf
->salt
;
12387 char *iter_pos
= input_buf
+ 9;
12389 char *salt_pos
= strchr (iter_pos
, '$');
12391 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12395 char *hash_pos
= strchr (salt_pos
, '$');
12397 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12399 uint salt_len
= hash_pos
- salt_pos
;
12401 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12403 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12405 salt
->salt_len
= salt_len
;
12407 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12409 salt
->salt_sign
[0] = atoi (salt_iter
);
12411 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12415 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12417 digest
[0] = byte_swap_64 (digest
[0]);
12418 digest
[1] = byte_swap_64 (digest
[1]);
12419 digest
[2] = byte_swap_64 (digest
[2]);
12420 digest
[3] = byte_swap_64 (digest
[3]);
12421 digest
[4] = byte_swap_64 (digest
[4]);
12422 digest
[5] = byte_swap_64 (digest
[5]);
12423 digest
[6] = byte_swap_64 (digest
[6]);
12424 digest
[7] = byte_swap_64 (digest
[7]);
12426 return (PARSER_OK
);
12429 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12431 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12433 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12435 salt_t
*salt
= hash_buf
->salt
;
12437 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12443 char *iterations_pos
= input_buf
;
12445 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12447 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12449 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12451 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12455 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12457 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12459 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12461 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12463 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12465 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12470 * pbkdf2 iterations
12473 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12476 * handle salt encoding
12479 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12481 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12483 const char p0
= saltbuf_pos
[i
+ 0];
12484 const char p1
= saltbuf_pos
[i
+ 1];
12486 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12487 | hex_convert (p0
) << 4;
12490 salt
->salt_len
= saltbuf_len
/ 2;
12493 * handle cipher encoding
12496 uint
*tmp
= (uint
*) mymalloc (32);
12498 char *cipherbuf_ptr
= (char *) tmp
;
12500 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12502 const char p0
= cipherbuf_pos
[i
+ 0];
12503 const char p1
= cipherbuf_pos
[i
+ 1];
12505 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12506 | hex_convert (p0
) << 4;
12509 // iv is stored at salt_buf 4 (length 16)
12510 // data is stored at salt_buf 8 (length 16)
12512 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12513 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12514 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12515 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12517 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12518 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12519 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12520 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12524 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12526 const char p0
= cipherbuf_pos
[j
+ 0];
12527 const char p1
= cipherbuf_pos
[j
+ 1];
12529 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12530 | hex_convert (p0
) << 4;
12537 digest
[0] = 0x10101010;
12538 digest
[1] = 0x10101010;
12539 digest
[2] = 0x10101010;
12540 digest
[3] = 0x10101010;
12542 return (PARSER_OK
);
12545 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12547 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12549 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12551 salt_t
*salt
= hash_buf
->salt
;
12553 char *hashbuf_pos
= input_buf
;
12555 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12557 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12559 uint hash_len
= iterations_pos
- hashbuf_pos
;
12561 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12565 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12567 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12569 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12573 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12575 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12577 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12579 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12581 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12583 salt
->salt_len
= salt_len
;
12585 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12587 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12588 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12589 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12590 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12592 return (PARSER_OK
);
12595 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12597 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12599 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12601 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12602 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12603 digest
[2] = hex_to_uint (&input_buf
[16]);
12604 digest
[3] = hex_to_uint (&input_buf
[24]);
12605 digest
[4] = hex_to_uint (&input_buf
[32]);
12606 digest
[5] = hex_to_uint (&input_buf
[40]);
12607 digest
[6] = hex_to_uint (&input_buf
[48]);
12608 digest
[7] = hex_to_uint (&input_buf
[56]);
12610 digest
[0] = byte_swap_32 (digest
[0]);
12611 digest
[1] = byte_swap_32 (digest
[1]);
12612 digest
[2] = byte_swap_32 (digest
[2]);
12613 digest
[3] = byte_swap_32 (digest
[3]);
12614 digest
[4] = byte_swap_32 (digest
[4]);
12615 digest
[5] = byte_swap_32 (digest
[5]);
12616 digest
[6] = byte_swap_32 (digest
[6]);
12617 digest
[7] = byte_swap_32 (digest
[7]);
12619 return (PARSER_OK
);
12622 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12624 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12626 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12628 salt_t
*salt
= hash_buf
->salt
;
12630 char *salt_pos
= input_buf
+ 3;
12632 uint iterations_len
= 0;
12634 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12638 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12640 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12641 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12645 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12649 iterations_len
+= 8;
12653 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12656 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12658 char *hash_pos
= strchr (salt_pos
, '$');
12660 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12662 uint salt_len
= hash_pos
- salt_pos
;
12664 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12666 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12668 salt
->salt_len
= salt_len
;
12672 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12674 return (PARSER_OK
);
12677 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12679 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12681 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12683 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12685 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12687 salt_t
*salt
= hash_buf
->salt
;
12689 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12691 char *iter_pos
= input_buf
+ 4;
12693 char *salt_pos
= strchr (iter_pos
, '$');
12695 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12699 char *hash_pos
= strchr (salt_pos
, '$');
12701 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12703 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12707 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12708 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12709 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12710 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12711 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12712 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12713 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12714 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12716 uint salt_len
= hash_pos
- salt_pos
- 1;
12718 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12720 salt
->salt_len
= salt_len
/ 2;
12722 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12723 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12724 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12725 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12726 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12727 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12728 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12729 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12731 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12732 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12733 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12734 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12735 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12736 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12737 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12738 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12739 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12740 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12742 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12744 salt
->salt_iter
= atoi (iter_pos
) - 1;
12746 return (PARSER_OK
);
12749 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12751 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12753 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12755 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12757 salt_t
*salt
= hash_buf
->salt
;
12759 char *salt_pos
= input_buf
+ 14;
12761 char *hash_pos
= strchr (salt_pos
, '*');
12763 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12767 uint salt_len
= hash_pos
- salt_pos
- 1;
12769 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12771 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12773 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12775 salt
->salt_len
= salt_len
;
12777 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12779 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12781 memcpy (digest
, tmp_buf
, 32);
12783 digest
[0] = byte_swap_32 (digest
[0]);
12784 digest
[1] = byte_swap_32 (digest
[1]);
12785 digest
[2] = byte_swap_32 (digest
[2]);
12786 digest
[3] = byte_swap_32 (digest
[3]);
12787 digest
[4] = byte_swap_32 (digest
[4]);
12788 digest
[5] = byte_swap_32 (digest
[5]);
12789 digest
[6] = byte_swap_32 (digest
[6]);
12790 digest
[7] = byte_swap_32 (digest
[7]);
12792 digest
[0] -= SHA256M_A
;
12793 digest
[1] -= SHA256M_B
;
12794 digest
[2] -= SHA256M_C
;
12795 digest
[3] -= SHA256M_D
;
12796 digest
[4] -= SHA256M_E
;
12797 digest
[5] -= SHA256M_F
;
12798 digest
[6] -= SHA256M_G
;
12799 digest
[7] -= SHA256M_H
;
12801 return (PARSER_OK
);
12804 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12806 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12808 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12810 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12812 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12814 salt_t
*salt
= hash_buf
->salt
;
12816 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12818 char *iter_pos
= input_buf
+ 19;
12820 char *salt_pos
= strchr (iter_pos
, '.');
12822 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12826 char *hash_pos
= strchr (salt_pos
, '.');
12828 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12830 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12834 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12835 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12836 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12837 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12838 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12839 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12840 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12841 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12843 uint salt_len
= hash_pos
- salt_pos
- 1;
12847 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12851 for (i
= 0; i
< salt_len
; i
++)
12853 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12856 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12857 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12859 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12861 salt
->salt_len
= salt_len
;
12863 salt
->salt_iter
= atoi (iter_pos
) - 1;
12865 return (PARSER_OK
);
12868 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12870 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12872 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12874 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12876 salt_t
*salt
= hash_buf
->salt
;
12880 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12882 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12884 memcpy (digest
, tmp_buf
, 64);
12886 digest
[0] = byte_swap_64 (digest
[0]);
12887 digest
[1] = byte_swap_64 (digest
[1]);
12888 digest
[2] = byte_swap_64 (digest
[2]);
12889 digest
[3] = byte_swap_64 (digest
[3]);
12890 digest
[4] = byte_swap_64 (digest
[4]);
12891 digest
[5] = byte_swap_64 (digest
[5]);
12892 digest
[6] = byte_swap_64 (digest
[6]);
12893 digest
[7] = byte_swap_64 (digest
[7]);
12895 digest
[0] -= SHA512M_A
;
12896 digest
[1] -= SHA512M_B
;
12897 digest
[2] -= SHA512M_C
;
12898 digest
[3] -= SHA512M_D
;
12899 digest
[4] -= SHA512M_E
;
12900 digest
[5] -= SHA512M_F
;
12901 digest
[6] -= SHA512M_G
;
12902 digest
[7] -= SHA512M_H
;
12904 salt
->salt_len
= tmp_len
- 64;
12906 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12908 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12910 char *ptr
= (char *) salt
->salt_buf
;
12912 ptr
[salt
->salt_len
] = 0x80;
12915 return (PARSER_OK
);
12918 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12920 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12922 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12926 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12929 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12931 salt_t
*salt
= hash_buf
->salt
;
12933 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12934 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12935 digest
[2] = hex_to_uint (&input_buf
[16]);
12936 digest
[3] = hex_to_uint (&input_buf
[24]);
12938 digest
[0] = byte_swap_32 (digest
[0]);
12939 digest
[1] = byte_swap_32 (digest
[1]);
12940 digest
[2] = byte_swap_32 (digest
[2]);
12941 digest
[3] = byte_swap_32 (digest
[3]);
12943 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12945 uint salt_len
= input_len
- 32 - 1;
12947 char *salt_buf
= input_buf
+ 32 + 1;
12949 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12951 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12953 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12955 salt
->salt_len
= salt_len
;
12957 return (PARSER_OK
);
12960 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12962 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12964 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
12968 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
12971 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12973 salt_t
*salt
= hash_buf
->salt
;
12975 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12976 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12977 digest
[2] = hex_to_uint (&input_buf
[16]);
12978 digest
[3] = hex_to_uint (&input_buf
[24]);
12979 digest
[4] = hex_to_uint (&input_buf
[32]);
12981 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12983 uint salt_len
= input_len
- 40 - 1;
12985 char *salt_buf
= input_buf
+ 40 + 1;
12987 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12989 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12991 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12993 salt
->salt_len
= salt_len
;
12995 return (PARSER_OK
);
12998 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13000 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13002 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13006 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13009 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13011 salt_t
*salt
= hash_buf
->salt
;
13013 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13014 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13015 digest
[2] = hex_to_uint (&input_buf
[16]);
13016 digest
[3] = hex_to_uint (&input_buf
[24]);
13017 digest
[4] = hex_to_uint (&input_buf
[32]);
13018 digest
[5] = hex_to_uint (&input_buf
[40]);
13019 digest
[6] = hex_to_uint (&input_buf
[48]);
13020 digest
[7] = hex_to_uint (&input_buf
[56]);
13022 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13024 uint salt_len
= input_len
- 64 - 1;
13026 char *salt_buf
= input_buf
+ 64 + 1;
13028 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13030 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13032 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13034 salt
->salt_len
= salt_len
;
13036 return (PARSER_OK
);
13039 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13041 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13043 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13047 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13050 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13052 salt_t
*salt
= hash_buf
->salt
;
13054 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13055 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13056 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13057 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13058 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13059 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13060 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13061 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13063 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13065 uint salt_len
= input_len
- 128 - 1;
13067 char *salt_buf
= input_buf
+ 128 + 1;
13069 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13071 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13073 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13075 salt
->salt_len
= salt_len
;
13077 return (PARSER_OK
);
13080 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13082 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13084 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13086 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13088 salt_t
*salt
= hash_buf
->salt
;
13090 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13096 char *user_pos
= input_buf
+ 10 + 1;
13098 char *realm_pos
= strchr (user_pos
, '$');
13100 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13102 uint user_len
= realm_pos
- user_pos
;
13104 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13108 char *salt_pos
= strchr (realm_pos
, '$');
13110 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13112 uint realm_len
= salt_pos
- realm_pos
;
13114 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13118 char *data_pos
= strchr (salt_pos
, '$');
13120 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13122 uint salt_len
= data_pos
- salt_pos
;
13124 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13128 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13130 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13136 memcpy (krb5pa
->user
, user_pos
, user_len
);
13137 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13138 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13140 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13142 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13144 const char p0
= data_pos
[i
+ 0];
13145 const char p1
= data_pos
[i
+ 1];
13147 *timestamp_ptr
++ = hex_convert (p1
) << 0
13148 | hex_convert (p0
) << 4;
13151 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13153 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13155 const char p0
= data_pos
[i
+ 0];
13156 const char p1
= data_pos
[i
+ 1];
13158 *checksum_ptr
++ = hex_convert (p1
) << 0
13159 | hex_convert (p0
) << 4;
13163 * copy some data to generic buffers to make sorting happy
13166 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13167 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13168 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13169 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13170 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13171 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13172 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13173 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13174 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13176 salt
->salt_len
= 36;
13178 digest
[0] = krb5pa
->checksum
[0];
13179 digest
[1] = krb5pa
->checksum
[1];
13180 digest
[2] = krb5pa
->checksum
[2];
13181 digest
[3] = krb5pa
->checksum
[3];
13183 return (PARSER_OK
);
13186 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13188 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13190 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13192 salt_t
*salt
= hash_buf
->salt
;
13198 char *salt_pos
= input_buf
;
13200 char *hash_pos
= strchr (salt_pos
, '$');
13202 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13204 uint salt_len
= hash_pos
- salt_pos
;
13206 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13210 uint hash_len
= input_len
- 1 - salt_len
;
13212 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13220 for (uint i
= 0; i
< salt_len
; i
++)
13222 if (salt_pos
[i
] == ' ') continue;
13227 // SAP user names cannot be longer than 12 characters
13228 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13230 // SAP user name cannot start with ! or ?
13231 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13237 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13239 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13241 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13243 salt
->salt_len
= salt_len
;
13245 digest
[0] = hex_to_uint (&hash_pos
[0]);
13246 digest
[1] = hex_to_uint (&hash_pos
[8]);
13250 digest
[0] = byte_swap_32 (digest
[0]);
13251 digest
[1] = byte_swap_32 (digest
[1]);
13253 return (PARSER_OK
);
13256 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13258 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13260 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13262 salt_t
*salt
= hash_buf
->salt
;
13268 char *salt_pos
= input_buf
;
13270 char *hash_pos
= strchr (salt_pos
, '$');
13272 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13274 uint salt_len
= hash_pos
- salt_pos
;
13276 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13280 uint hash_len
= input_len
- 1 - salt_len
;
13282 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13290 for (uint i
= 0; i
< salt_len
; i
++)
13292 if (salt_pos
[i
] == ' ') continue;
13297 // SAP user names cannot be longer than 12 characters
13298 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13300 // SAP user name cannot start with ! or ?
13301 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13313 salt
->salt_len
= salt_len
;
13315 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13316 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13317 digest
[2] = hex_to_uint (&hash_pos
[16]);
13318 digest
[3] = hex_to_uint (&hash_pos
[24]);
13319 digest
[4] = hex_to_uint (&hash_pos
[32]);
13321 return (PARSER_OK
);
13324 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13326 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13328 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13330 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13332 salt_t
*salt
= hash_buf
->salt
;
13334 char *iter_pos
= input_buf
+ 3;
13336 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13338 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13340 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13342 salt
->salt_iter
= salt_iter
;
13344 char *salt_pos
= iter_pos
+ 1;
13348 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13350 salt
->salt_len
= salt_len
;
13352 char *hash_pos
= salt_pos
+ salt_len
;
13354 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13358 char *tmp
= (char *) salt
->salt_buf_pc
;
13360 tmp
[0] = hash_pos
[42];
13364 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13365 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13366 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13367 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13373 return (PARSER_OK
);
13376 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13378 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13380 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13382 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13384 salt_t
*salt
= hash_buf
->salt
;
13386 char *salt_buf
= input_buf
+ 6;
13388 uint salt_len
= 16;
13390 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13392 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13394 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13396 salt
->salt_len
= salt_len
;
13398 char *hash_pos
= input_buf
+ 6 + 16;
13400 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13401 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13402 digest
[2] = hex_to_uint (&hash_pos
[16]);
13403 digest
[3] = hex_to_uint (&hash_pos
[24]);
13404 digest
[4] = hex_to_uint (&hash_pos
[32]);
13405 digest
[5] = hex_to_uint (&hash_pos
[40]);
13406 digest
[6] = hex_to_uint (&hash_pos
[48]);
13407 digest
[7] = hex_to_uint (&hash_pos
[56]);
13409 return (PARSER_OK
);
13412 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13414 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13416 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13418 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13419 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13423 return (PARSER_OK
);
13426 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13428 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13430 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13432 salt_t
*salt
= hash_buf
->salt
;
13434 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13436 char *saltbuf_pos
= input_buf
;
13438 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13440 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13442 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13444 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13445 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13447 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13451 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13453 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13455 char *salt_ptr
= (char *) saltbuf_pos
;
13456 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13461 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13463 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13466 rakp_ptr
[j
] = 0x80;
13468 rakp
->salt_len
= j
;
13470 for (i
= 0; i
< 64; i
++)
13472 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13475 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13476 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13477 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13478 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13479 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13480 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13481 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13482 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13484 salt
->salt_len
= 32; // muss min. 32 haben
13486 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13487 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13488 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13489 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13490 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13492 return (PARSER_OK
);
13495 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13497 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13499 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13501 salt_t
*salt
= hash_buf
->salt
;
13503 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13505 char *salt_pos
= input_buf
+ 1;
13507 memcpy (salt
->salt_buf
, salt_pos
, 8);
13509 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13510 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13512 salt
->salt_len
= 8;
13514 char *hash_pos
= salt_pos
+ 8;
13516 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13517 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13518 digest
[2] = hex_to_uint (&hash_pos
[16]);
13519 digest
[3] = hex_to_uint (&hash_pos
[24]);
13520 digest
[4] = hex_to_uint (&hash_pos
[32]);
13522 digest
[0] -= SHA1M_A
;
13523 digest
[1] -= SHA1M_B
;
13524 digest
[2] -= SHA1M_C
;
13525 digest
[3] -= SHA1M_D
;
13526 digest
[4] -= SHA1M_E
;
13528 return (PARSER_OK
);
13531 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13533 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13535 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13537 salt_t
*salt
= hash_buf
->salt
;
13539 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13540 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13541 digest
[2] = hex_to_uint (&input_buf
[16]);
13542 digest
[3] = hex_to_uint (&input_buf
[24]);
13544 digest
[0] = byte_swap_32 (digest
[0]);
13545 digest
[1] = byte_swap_32 (digest
[1]);
13546 digest
[2] = byte_swap_32 (digest
[2]);
13547 digest
[3] = byte_swap_32 (digest
[3]);
13549 digest
[0] -= MD5M_A
;
13550 digest
[1] -= MD5M_B
;
13551 digest
[2] -= MD5M_C
;
13552 digest
[3] -= MD5M_D
;
13554 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13556 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13558 uint32_t *salt_buf
= salt
->salt_buf
;
13560 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13561 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13562 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13563 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13565 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13566 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13567 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13568 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13570 salt
->salt_len
= 16 + 1;
13572 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13574 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13576 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13578 return (PARSER_OK
);
13581 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13583 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13585 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13587 salt_t
*salt
= hash_buf
->salt
;
13589 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13595 char *hashbuf_pos
= input_buf
;
13597 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13599 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13601 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13603 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13607 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13609 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13611 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13613 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13617 char *databuf_pos
= strchr (iteration_pos
, ':');
13619 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13621 const uint iteration_len
= databuf_pos
- iteration_pos
;
13623 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13624 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13626 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13628 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13629 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13635 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13636 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13637 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13638 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13639 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13640 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13641 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13642 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13646 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13648 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13650 const char p0
= saltbuf_pos
[i
+ 0];
13651 const char p1
= saltbuf_pos
[i
+ 1];
13653 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13654 | hex_convert (p0
) << 4;
13657 salt
->salt_buf
[4] = 0x01000000;
13658 salt
->salt_buf
[5] = 0x80;
13660 salt
->salt_len
= saltbuf_len
/ 2;
13664 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13668 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13670 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13672 const char p0
= databuf_pos
[i
+ 0];
13673 const char p1
= databuf_pos
[i
+ 1];
13675 *databuf_ptr
++ = hex_convert (p1
) << 0
13676 | hex_convert (p0
) << 4;
13679 *databuf_ptr
++ = 0x80;
13681 for (uint i
= 0; i
< 512; i
++)
13683 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13686 cloudkey
->data_len
= databuf_len
/ 2;
13688 return (PARSER_OK
);
13691 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13693 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13695 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13697 salt_t
*salt
= hash_buf
->salt
;
13703 char *hashbuf_pos
= input_buf
;
13705 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13707 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13709 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13711 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13715 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13717 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13719 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13721 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13723 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13727 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13729 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13731 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13733 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13735 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13739 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13741 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13742 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13744 // ok, the plan for this algorithm is the following:
13745 // we have 2 salts here, the domain-name and a random salt
13746 // while both are used in the initial transformation,
13747 // only the random salt is used in the following iterations
13748 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13749 // and one that includes only the real salt (stored into salt_buf[]).
13750 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13752 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13754 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13756 memcpy (digest
, tmp_buf
, 20);
13758 digest
[0] = byte_swap_32 (digest
[0]);
13759 digest
[1] = byte_swap_32 (digest
[1]);
13760 digest
[2] = byte_swap_32 (digest
[2]);
13761 digest
[3] = byte_swap_32 (digest
[3]);
13762 digest
[4] = byte_swap_32 (digest
[4]);
13766 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13768 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13770 char *len_ptr
= NULL
;
13772 for (uint i
= 0; i
< domainbuf_len
; i
++)
13774 if (salt_buf_pc_ptr
[i
] == '.')
13776 len_ptr
= &salt_buf_pc_ptr
[i
];
13786 salt
->salt_buf_pc
[7] = domainbuf_len
;
13790 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13792 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13794 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13796 salt
->salt_len
= salt_len
;
13800 salt
->salt_iter
= atoi (iteration_pos
);
13802 return (PARSER_OK
);
13805 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13807 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13809 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13811 salt_t
*salt
= hash_buf
->salt
;
13813 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13814 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13815 digest
[2] = hex_to_uint (&input_buf
[16]);
13816 digest
[3] = hex_to_uint (&input_buf
[24]);
13817 digest
[4] = hex_to_uint (&input_buf
[32]);
13819 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13821 uint salt_len
= input_len
- 40 - 1;
13823 char *salt_buf
= input_buf
+ 40 + 1;
13825 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13827 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13829 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13831 salt
->salt_len
= salt_len
;
13833 return (PARSER_OK
);
13836 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13838 const uint8_t ascii_to_ebcdic
[] =
13840 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13841 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13842 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13843 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13844 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13845 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13846 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13847 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13848 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13849 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13850 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13851 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13852 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13853 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13854 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13855 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13858 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13860 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13862 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13864 salt_t
*salt
= hash_buf
->salt
;
13866 char *salt_pos
= input_buf
+ 6 + 1;
13868 char *digest_pos
= strchr (salt_pos
, '*');
13870 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13872 uint salt_len
= digest_pos
- salt_pos
;
13874 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13876 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13878 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13882 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13883 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13885 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13887 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13889 salt
->salt_len
= salt_len
;
13891 for (uint i
= 0; i
< salt_len
; i
++)
13893 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13895 for (uint i
= salt_len
; i
< 8; i
++)
13897 salt_buf_pc_ptr
[i
] = 0x40;
13902 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13904 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13905 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13907 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13908 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13910 digest
[0] = byte_swap_32 (digest
[0]);
13911 digest
[1] = byte_swap_32 (digest
[1]);
13913 IP (digest
[0], digest
[1], tt
);
13915 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13916 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13920 return (PARSER_OK
);
13923 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13925 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13927 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13929 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13930 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13931 digest
[2] = hex_to_uint (&input_buf
[16]);
13932 digest
[3] = hex_to_uint (&input_buf
[24]);
13934 digest
[0] = byte_swap_32 (digest
[0]);
13935 digest
[1] = byte_swap_32 (digest
[1]);
13936 digest
[2] = byte_swap_32 (digest
[2]);
13937 digest
[3] = byte_swap_32 (digest
[3]);
13939 return (PARSER_OK
);
13942 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13944 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13946 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13948 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13950 salt_t
*salt
= hash_buf
->salt
;
13954 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13956 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13958 tmp_buf
[3] += -4; // dont ask!
13960 memcpy (salt
->salt_buf
, tmp_buf
, 5);
13962 salt
->salt_len
= 5;
13964 memcpy (digest
, tmp_buf
+ 5, 9);
13966 // yes, only 9 byte are needed to crack, but 10 to display
13968 salt
->salt_buf_pc
[7] = input_buf
[20];
13970 return (PARSER_OK
);
13973 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13975 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
13977 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13979 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13981 salt_t
*salt
= hash_buf
->salt
;
13985 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13987 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13989 tmp_buf
[3] += -4; // dont ask!
13993 memcpy (salt
->salt_buf
, tmp_buf
, 16);
13995 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)
13999 char tmp_iter_buf
[11];
14001 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14003 tmp_iter_buf
[10] = 0;
14005 salt
->salt_iter
= atoi (tmp_iter_buf
);
14007 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14009 return (PARSER_SALT_ITERATION
);
14012 salt
->salt_iter
--; // first round in init
14014 // 2 additional bytes for display only
14016 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14017 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14021 memcpy (digest
, tmp_buf
+ 28, 8);
14023 digest
[0] = byte_swap_32 (digest
[0]);
14024 digest
[1] = byte_swap_32 (digest
[1]);
14028 return (PARSER_OK
);
14031 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14033 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14035 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14037 salt_t
*salt
= hash_buf
->salt
;
14039 char *salt_buf_pos
= input_buf
;
14041 char *hash_buf_pos
= salt_buf_pos
+ 6;
14043 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14044 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14045 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14046 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14047 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14048 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14049 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14050 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14052 digest
[0] -= SHA256M_A
;
14053 digest
[1] -= SHA256M_B
;
14054 digest
[2] -= SHA256M_C
;
14055 digest
[3] -= SHA256M_D
;
14056 digest
[4] -= SHA256M_E
;
14057 digest
[5] -= SHA256M_F
;
14058 digest
[6] -= SHA256M_G
;
14059 digest
[7] -= SHA256M_H
;
14061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14063 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14065 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14067 salt
->salt_len
= salt_len
;
14069 return (PARSER_OK
);
14072 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14074 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14076 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14078 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14080 salt_t
*salt
= hash_buf
->salt
;
14082 char *salt_buf
= input_buf
+ 6;
14084 char *digest_buf
= strchr (salt_buf
, '$');
14086 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14088 uint salt_len
= digest_buf
- salt_buf
;
14090 digest_buf
++; // skip the '$' symbol
14092 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14094 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14096 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14098 salt
->salt_len
= salt_len
;
14100 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14101 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14102 digest
[2] = hex_to_uint (&digest_buf
[16]);
14103 digest
[3] = hex_to_uint (&digest_buf
[24]);
14105 digest
[0] = byte_swap_32 (digest
[0]);
14106 digest
[1] = byte_swap_32 (digest
[1]);
14107 digest
[2] = byte_swap_32 (digest
[2]);
14108 digest
[3] = byte_swap_32 (digest
[3]);
14110 digest
[0] -= MD5M_A
;
14111 digest
[1] -= MD5M_B
;
14112 digest
[2] -= MD5M_C
;
14113 digest
[3] -= MD5M_D
;
14115 return (PARSER_OK
);
14118 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14120 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14122 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14124 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14126 salt_t
*salt
= hash_buf
->salt
;
14128 char *salt_buf
= input_buf
+ 3;
14130 char *digest_buf
= strchr (salt_buf
, '$');
14132 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14134 uint salt_len
= digest_buf
- salt_buf
;
14136 digest_buf
++; // skip the '$' symbol
14138 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14140 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14142 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14144 salt_buf_ptr
[salt_len
] = 0x2d;
14146 salt
->salt_len
= salt_len
+ 1;
14148 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14149 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14150 digest
[2] = hex_to_uint (&digest_buf
[16]);
14151 digest
[3] = hex_to_uint (&digest_buf
[24]);
14153 digest
[0] = byte_swap_32 (digest
[0]);
14154 digest
[1] = byte_swap_32 (digest
[1]);
14155 digest
[2] = byte_swap_32 (digest
[2]);
14156 digest
[3] = byte_swap_32 (digest
[3]);
14158 digest
[0] -= MD5M_A
;
14159 digest
[1] -= MD5M_B
;
14160 digest
[2] -= MD5M_C
;
14161 digest
[3] -= MD5M_D
;
14163 return (PARSER_OK
);
14166 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14168 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14170 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14174 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14176 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14178 memcpy (digest
, tmp_buf
, 20);
14180 digest
[0] = byte_swap_32 (digest
[0]);
14181 digest
[1] = byte_swap_32 (digest
[1]);
14182 digest
[2] = byte_swap_32 (digest
[2]);
14183 digest
[3] = byte_swap_32 (digest
[3]);
14184 digest
[4] = byte_swap_32 (digest
[4]);
14186 digest
[0] -= SHA1M_A
;
14187 digest
[1] -= SHA1M_B
;
14188 digest
[2] -= SHA1M_C
;
14189 digest
[3] -= SHA1M_D
;
14190 digest
[4] -= SHA1M_E
;
14192 return (PARSER_OK
);
14195 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14197 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14199 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14201 salt_t
*salt
= hash_buf
->salt
;
14203 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14204 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14205 digest
[2] = hex_to_uint (&input_buf
[16]);
14206 digest
[3] = hex_to_uint (&input_buf
[24]);
14208 digest
[0] = byte_swap_32 (digest
[0]);
14209 digest
[1] = byte_swap_32 (digest
[1]);
14210 digest
[2] = byte_swap_32 (digest
[2]);
14211 digest
[3] = byte_swap_32 (digest
[3]);
14213 digest
[0] -= MD5M_A
;
14214 digest
[1] -= MD5M_B
;
14215 digest
[2] -= MD5M_C
;
14216 digest
[3] -= MD5M_D
;
14218 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14220 uint salt_len
= input_len
- 32 - 1;
14222 char *salt_buf
= input_buf
+ 32 + 1;
14224 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14226 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14228 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14231 * add static "salt" part
14234 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14238 salt
->salt_len
= salt_len
;
14240 return (PARSER_OK
);
14243 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14245 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14247 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14249 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14251 salt_t
*salt
= hash_buf
->salt
;
14253 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14259 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14261 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14263 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14265 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14267 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14271 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14273 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14275 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14277 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14281 char *keybuf_pos
= strchr (keylen_pos
, '$');
14283 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14285 uint keylen_len
= keybuf_pos
- keylen_pos
;
14287 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14291 char *databuf_pos
= strchr (keybuf_pos
, '$');
14293 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14295 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14297 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14301 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14303 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14309 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14310 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14311 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14312 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14314 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14315 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14316 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14317 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14319 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14320 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14321 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14322 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14324 salt
->salt_len
= 16;
14325 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14327 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14329 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14332 return (PARSER_OK
);
14335 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14337 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14339 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14341 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14343 salt_t
*salt
= hash_buf
->salt
;
14349 // first is the N salt parameter
14351 char *N_pos
= input_buf
+ 6;
14353 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14357 salt
->scrypt_N
= atoi (N_pos
);
14361 char *r_pos
= strchr (N_pos
, ':');
14363 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14367 salt
->scrypt_r
= atoi (r_pos
);
14371 char *p_pos
= strchr (r_pos
, ':');
14373 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14377 salt
->scrypt_p
= atoi (p_pos
);
14381 char *saltbuf_pos
= strchr (p_pos
, ':');
14383 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14387 char *hash_pos
= strchr (saltbuf_pos
, ':');
14389 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14397 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14399 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14401 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14403 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14405 salt
->salt_len
= tmp_len
;
14406 salt
->salt_iter
= 1;
14408 // digest - base64 decode
14410 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14412 tmp_len
= input_len
- (hash_pos
- input_buf
);
14414 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14416 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14418 memcpy (digest
, tmp_buf
, 32);
14420 return (PARSER_OK
);
14423 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14425 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14427 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14429 salt_t
*salt
= hash_buf
->salt
;
14435 char decrypted
[76]; // iv + hash
14437 juniper_decrypt_hash (input_buf
, decrypted
);
14439 char *md5crypt_hash
= decrypted
+ 12;
14441 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14443 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14445 char *salt_pos
= md5crypt_hash
+ 3;
14447 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14449 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14451 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14455 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14457 return (PARSER_OK
);
14460 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14462 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14464 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14466 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14468 salt_t
*salt
= hash_buf
->salt
;
14470 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14476 // first is *raw* salt
14478 char *salt_pos
= input_buf
+ 3;
14480 char *hash_pos
= strchr (salt_pos
, '$');
14482 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14484 uint salt_len
= hash_pos
- salt_pos
;
14486 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14490 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14492 memcpy (salt_buf_ptr
, salt_pos
, 14);
14494 salt_buf_ptr
[17] = 0x01;
14495 salt_buf_ptr
[18] = 0x80;
14497 // add some stuff to normal salt to make sorted happy
14499 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14500 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14501 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14502 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14504 salt
->salt_len
= salt_len
;
14505 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14507 // base64 decode hash
14511 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14513 uint hash_len
= input_len
- 3 - salt_len
- 1;
14515 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14517 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14519 memcpy (digest
, tmp_buf
, 32);
14521 digest
[0] = byte_swap_32 (digest
[0]);
14522 digest
[1] = byte_swap_32 (digest
[1]);
14523 digest
[2] = byte_swap_32 (digest
[2]);
14524 digest
[3] = byte_swap_32 (digest
[3]);
14525 digest
[4] = byte_swap_32 (digest
[4]);
14526 digest
[5] = byte_swap_32 (digest
[5]);
14527 digest
[6] = byte_swap_32 (digest
[6]);
14528 digest
[7] = byte_swap_32 (digest
[7]);
14530 return (PARSER_OK
);
14533 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14535 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14537 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14539 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14541 salt_t
*salt
= hash_buf
->salt
;
14547 // first is *raw* salt
14549 char *salt_pos
= input_buf
+ 3;
14551 char *hash_pos
= strchr (salt_pos
, '$');
14553 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14555 uint salt_len
= hash_pos
- salt_pos
;
14557 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14559 salt
->salt_len
= salt_len
;
14562 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14564 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14565 salt_buf_ptr
[salt_len
] = 0;
14567 // base64 decode hash
14571 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14573 uint hash_len
= input_len
- 3 - salt_len
- 1;
14575 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14577 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14579 memcpy (digest
, tmp_buf
, 32);
14582 salt
->scrypt_N
= 16384;
14583 salt
->scrypt_r
= 1;
14584 salt
->scrypt_p
= 1;
14585 salt
->salt_iter
= 1;
14587 return (PARSER_OK
);
14590 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14592 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14594 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14596 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14598 salt_t
*salt
= hash_buf
->salt
;
14600 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14606 char *version_pos
= input_buf
+ 8 + 1;
14608 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14610 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14612 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14614 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14616 verifierHashSize_pos
++;
14618 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14620 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14622 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14624 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14628 char *saltSize_pos
= strchr (keySize_pos
, '*');
14630 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14632 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14634 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14638 char *osalt_pos
= strchr (saltSize_pos
, '*');
14640 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14642 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14644 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14648 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14650 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14652 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14654 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14656 encryptedVerifier_pos
++;
14658 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14660 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14662 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14664 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14666 encryptedVerifierHash_pos
++;
14668 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;
14670 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14672 const uint version
= atoi (version_pos
);
14674 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14676 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14678 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14680 const uint keySize
= atoi (keySize_pos
);
14682 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14684 office2007
->keySize
= keySize
;
14686 const uint saltSize
= atoi (saltSize_pos
);
14688 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14694 salt
->salt_len
= 16;
14695 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14697 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14698 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14699 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14700 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14706 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14707 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14708 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14709 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14711 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14712 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14713 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14714 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14715 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14721 digest
[0] = office2007
->encryptedVerifierHash
[0];
14722 digest
[1] = office2007
->encryptedVerifierHash
[1];
14723 digest
[2] = office2007
->encryptedVerifierHash
[2];
14724 digest
[3] = office2007
->encryptedVerifierHash
[3];
14726 return (PARSER_OK
);
14729 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14731 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14733 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14735 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14737 salt_t
*salt
= hash_buf
->salt
;
14739 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14745 char *version_pos
= input_buf
+ 8 + 1;
14747 char *spinCount_pos
= strchr (version_pos
, '*');
14749 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14751 uint32_t version_len
= spinCount_pos
- version_pos
;
14753 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14757 char *keySize_pos
= strchr (spinCount_pos
, '*');
14759 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14761 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14763 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14767 char *saltSize_pos
= strchr (keySize_pos
, '*');
14769 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14771 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14773 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14777 char *osalt_pos
= strchr (saltSize_pos
, '*');
14779 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14781 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14783 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14787 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14789 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14791 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14793 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14795 encryptedVerifier_pos
++;
14797 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14799 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14801 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14803 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14805 encryptedVerifierHash_pos
++;
14807 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;
14809 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14811 const uint version
= atoi (version_pos
);
14813 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14815 const uint spinCount
= atoi (spinCount_pos
);
14817 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14819 const uint keySize
= atoi (keySize_pos
);
14821 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14823 const uint saltSize
= atoi (saltSize_pos
);
14825 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14831 salt
->salt_len
= 16;
14832 salt
->salt_iter
= spinCount
;
14834 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14835 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14836 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14837 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14843 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14844 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14845 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14846 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14848 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14849 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14850 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14851 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14852 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14853 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14854 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14855 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14861 digest
[0] = office2010
->encryptedVerifierHash
[0];
14862 digest
[1] = office2010
->encryptedVerifierHash
[1];
14863 digest
[2] = office2010
->encryptedVerifierHash
[2];
14864 digest
[3] = office2010
->encryptedVerifierHash
[3];
14866 return (PARSER_OK
);
14869 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14871 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14873 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14875 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14877 salt_t
*salt
= hash_buf
->salt
;
14879 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14885 char *version_pos
= input_buf
+ 8 + 1;
14887 char *spinCount_pos
= strchr (version_pos
, '*');
14889 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14891 uint32_t version_len
= spinCount_pos
- version_pos
;
14893 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14897 char *keySize_pos
= strchr (spinCount_pos
, '*');
14899 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14901 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14903 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14907 char *saltSize_pos
= strchr (keySize_pos
, '*');
14909 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14911 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14913 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14917 char *osalt_pos
= strchr (saltSize_pos
, '*');
14919 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14921 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14923 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14927 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14929 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14931 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14933 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14935 encryptedVerifier_pos
++;
14937 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14939 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14941 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14943 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14945 encryptedVerifierHash_pos
++;
14947 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;
14949 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14951 const uint version
= atoi (version_pos
);
14953 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14955 const uint spinCount
= atoi (spinCount_pos
);
14957 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14959 const uint keySize
= atoi (keySize_pos
);
14961 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
14963 const uint saltSize
= atoi (saltSize_pos
);
14965 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14971 salt
->salt_len
= 16;
14972 salt
->salt_iter
= spinCount
;
14974 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14975 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14976 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14977 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14983 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14984 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14985 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14986 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14988 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14989 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14990 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14991 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14992 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14993 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14994 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14995 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15001 digest
[0] = office2013
->encryptedVerifierHash
[0];
15002 digest
[1] = office2013
->encryptedVerifierHash
[1];
15003 digest
[2] = office2013
->encryptedVerifierHash
[2];
15004 digest
[3] = office2013
->encryptedVerifierHash
[3];
15006 return (PARSER_OK
);
15009 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15011 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15013 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15015 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15017 salt_t
*salt
= hash_buf
->salt
;
15019 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15025 char *version_pos
= input_buf
+ 11;
15027 char *osalt_pos
= strchr (version_pos
, '*');
15029 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15031 uint32_t version_len
= osalt_pos
- version_pos
;
15033 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15037 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15039 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15041 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15043 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15045 encryptedVerifier_pos
++;
15047 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15049 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15051 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15053 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15055 encryptedVerifierHash_pos
++;
15057 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15059 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15061 const uint version
= *version_pos
- 0x30;
15063 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15069 oldoffice01
->version
= version
;
15071 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15072 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15073 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15074 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15076 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15077 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15078 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15079 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15081 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15082 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15083 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15084 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15086 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15087 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15088 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15089 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15095 salt
->salt_len
= 16;
15097 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15098 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15099 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15100 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15102 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15103 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15104 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15105 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15107 // this is a workaround as office produces multiple documents with the same salt
15109 salt
->salt_len
+= 32;
15111 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15112 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15113 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15114 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15115 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15116 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15117 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15118 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15124 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15125 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15126 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15127 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15129 return (PARSER_OK
);
15132 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15134 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15137 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15139 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15141 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15143 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15145 salt_t
*salt
= hash_buf
->salt
;
15147 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15153 char *version_pos
= input_buf
+ 11;
15155 char *osalt_pos
= strchr (version_pos
, '*');
15157 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15159 uint32_t version_len
= osalt_pos
- version_pos
;
15161 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15165 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15167 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15169 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15171 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15173 encryptedVerifier_pos
++;
15175 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15177 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15179 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15181 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15183 encryptedVerifierHash_pos
++;
15185 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15187 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15189 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15191 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15195 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15197 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15199 const uint version
= *version_pos
- 0x30;
15201 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15207 oldoffice01
->version
= version
;
15209 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15210 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15211 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15212 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15214 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15215 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15216 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15217 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15219 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15220 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15221 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15222 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15224 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15225 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15226 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15227 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15229 oldoffice01
->rc4key
[1] = 0;
15230 oldoffice01
->rc4key
[0] = 0;
15232 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15233 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15234 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15235 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15236 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15237 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15238 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15239 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15240 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15241 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15243 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15244 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15250 salt
->salt_len
= 16;
15252 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15253 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15254 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15255 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15257 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15258 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15259 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15260 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15262 // this is a workaround as office produces multiple documents with the same salt
15264 salt
->salt_len
+= 32;
15266 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15267 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15268 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15269 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15270 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15271 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15272 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15273 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15279 digest
[0] = oldoffice01
->rc4key
[0];
15280 digest
[1] = oldoffice01
->rc4key
[1];
15284 return (PARSER_OK
);
15287 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15289 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15291 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15293 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15295 salt_t
*salt
= hash_buf
->salt
;
15297 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15303 char *version_pos
= input_buf
+ 11;
15305 char *osalt_pos
= strchr (version_pos
, '*');
15307 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15309 uint32_t version_len
= osalt_pos
- version_pos
;
15311 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15315 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15317 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15319 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15321 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15323 encryptedVerifier_pos
++;
15325 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15327 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15329 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15331 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15333 encryptedVerifierHash_pos
++;
15335 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15337 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15339 const uint version
= *version_pos
- 0x30;
15341 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15347 oldoffice34
->version
= version
;
15349 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15350 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15351 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15352 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15354 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15355 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15356 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15357 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15359 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15360 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15361 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15362 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15363 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15365 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15366 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15367 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15368 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15369 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15375 salt
->salt_len
= 16;
15377 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15378 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15379 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15380 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15382 // this is a workaround as office produces multiple documents with the same salt
15384 salt
->salt_len
+= 32;
15386 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15387 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15388 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15389 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15390 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15391 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15392 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15393 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15399 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15400 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15401 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15402 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15404 return (PARSER_OK
);
15407 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15409 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15411 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15414 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15416 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15418 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15420 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15422 salt_t
*salt
= hash_buf
->salt
;
15424 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15430 char *version_pos
= input_buf
+ 11;
15432 char *osalt_pos
= strchr (version_pos
, '*');
15434 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15436 uint32_t version_len
= osalt_pos
- version_pos
;
15438 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15442 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15444 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15446 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15448 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15450 encryptedVerifier_pos
++;
15452 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15454 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15456 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15458 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15460 encryptedVerifierHash_pos
++;
15462 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15464 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15466 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15468 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15472 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15474 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15476 const uint version
= *version_pos
- 0x30;
15478 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15484 oldoffice34
->version
= version
;
15486 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15487 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15488 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15489 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15491 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15492 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15493 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15494 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15496 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15497 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15498 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15499 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15500 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15502 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15503 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15504 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15505 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15506 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15508 oldoffice34
->rc4key
[1] = 0;
15509 oldoffice34
->rc4key
[0] = 0;
15511 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15512 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15513 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15514 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15515 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15516 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15517 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15518 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15519 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15520 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15522 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15523 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15529 salt
->salt_len
= 16;
15531 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15532 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15533 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15534 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15536 // this is a workaround as office produces multiple documents with the same salt
15538 salt
->salt_len
+= 32;
15540 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15541 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15542 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15543 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15544 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15545 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15546 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15547 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15553 digest
[0] = oldoffice34
->rc4key
[0];
15554 digest
[1] = oldoffice34
->rc4key
[1];
15558 return (PARSER_OK
);
15561 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15563 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15565 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15567 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15568 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15569 digest
[2] = hex_to_uint (&input_buf
[16]);
15570 digest
[3] = hex_to_uint (&input_buf
[24]);
15572 digest
[0] = byte_swap_32 (digest
[0]);
15573 digest
[1] = byte_swap_32 (digest
[1]);
15574 digest
[2] = byte_swap_32 (digest
[2]);
15575 digest
[3] = byte_swap_32 (digest
[3]);
15577 return (PARSER_OK
);
15580 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15582 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15584 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15586 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15588 salt_t
*salt
= hash_buf
->salt
;
15590 char *signature_pos
= input_buf
;
15592 char *salt_pos
= strchr (signature_pos
, '$');
15594 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15596 uint32_t signature_len
= salt_pos
- signature_pos
;
15598 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15602 char *hash_pos
= strchr (salt_pos
, '$');
15604 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15606 uint32_t salt_len
= hash_pos
- salt_pos
;
15608 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15612 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15614 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15616 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15617 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15618 digest
[2] = hex_to_uint (&hash_pos
[16]);
15619 digest
[3] = hex_to_uint (&hash_pos
[24]);
15620 digest
[4] = hex_to_uint (&hash_pos
[32]);
15622 digest
[0] -= SHA1M_A
;
15623 digest
[1] -= SHA1M_B
;
15624 digest
[2] -= SHA1M_C
;
15625 digest
[3] -= SHA1M_D
;
15626 digest
[4] -= SHA1M_E
;
15628 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15630 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15632 salt
->salt_len
= salt_len
;
15634 return (PARSER_OK
);
15637 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15639 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15641 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15643 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15645 salt_t
*salt
= hash_buf
->salt
;
15647 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15653 char *iter_pos
= input_buf
+ 14;
15655 const int iter
= atoi (iter_pos
);
15657 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15659 salt
->salt_iter
= iter
- 1;
15661 char *salt_pos
= strchr (iter_pos
, '$');
15663 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15667 char *hash_pos
= strchr (salt_pos
, '$');
15669 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15671 const uint salt_len
= hash_pos
- salt_pos
;
15675 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15677 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15679 salt
->salt_len
= salt_len
;
15681 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15682 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15684 // add some stuff to normal salt to make sorted happy
15686 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15687 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15688 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15689 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15690 salt
->salt_buf
[4] = salt
->salt_iter
;
15692 // base64 decode hash
15696 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15698 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15700 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15702 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15704 memcpy (digest
, tmp_buf
, 32);
15706 digest
[0] = byte_swap_32 (digest
[0]);
15707 digest
[1] = byte_swap_32 (digest
[1]);
15708 digest
[2] = byte_swap_32 (digest
[2]);
15709 digest
[3] = byte_swap_32 (digest
[3]);
15710 digest
[4] = byte_swap_32 (digest
[4]);
15711 digest
[5] = byte_swap_32 (digest
[5]);
15712 digest
[6] = byte_swap_32 (digest
[6]);
15713 digest
[7] = byte_swap_32 (digest
[7]);
15715 return (PARSER_OK
);
15718 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15720 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15722 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15724 salt_t
*salt
= hash_buf
->salt
;
15726 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15727 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15731 digest
[0] = byte_swap_32 (digest
[0]);
15732 digest
[1] = byte_swap_32 (digest
[1]);
15734 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15735 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15736 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15738 char iter_c
= input_buf
[17];
15739 char iter_d
= input_buf
[19];
15741 // atm only defaults, let's see if there's more request
15742 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15743 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15745 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15747 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15748 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15749 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15750 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15752 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15753 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15754 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15755 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15757 salt
->salt_len
= 16;
15759 return (PARSER_OK
);
15762 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15764 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15766 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15768 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15770 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15772 salt_t
*salt
= hash_buf
->salt
;
15774 char *salt_pos
= input_buf
+ 10;
15776 char *hash_pos
= strchr (salt_pos
, '$');
15778 uint salt_len
= hash_pos
- salt_pos
;
15780 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15784 uint hash_len
= input_len
- 10 - salt_len
- 1;
15786 // base64 decode salt
15790 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15792 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15794 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15796 tmp_buf
[salt_len
] = 0x80;
15798 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15800 salt
->salt_len
= salt_len
;
15802 // base64 decode salt
15804 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15806 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15808 uint user_len
= hash_len
- 32;
15810 char *tmp_hash
= tmp_buf
+ user_len
;
15812 user_len
--; // skip the trailing space
15814 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15815 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15816 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15817 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15819 digest
[0] = byte_swap_32 (digest
[0]);
15820 digest
[1] = byte_swap_32 (digest
[1]);
15821 digest
[2] = byte_swap_32 (digest
[2]);
15822 digest
[3] = byte_swap_32 (digest
[3]);
15824 // store username for host only (output hash if cracked)
15826 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15827 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15829 return (PARSER_OK
);
15832 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15834 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15836 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15838 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15840 salt_t
*salt
= hash_buf
->salt
;
15842 char *iter_pos
= input_buf
+ 10;
15844 uint32_t iter
= atoi (iter_pos
);
15848 return (PARSER_SALT_ITERATION
);
15851 iter
--; // first iteration is special
15853 salt
->salt_iter
= iter
;
15855 char *base64_pos
= strchr (iter_pos
, '}');
15857 if (base64_pos
== NULL
)
15859 return (PARSER_SIGNATURE_UNMATCHED
);
15864 // base64 decode salt
15866 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15870 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15872 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15874 if (decoded_len
< 24)
15876 return (PARSER_SALT_LENGTH
);
15881 uint salt_len
= decoded_len
- 20;
15883 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15884 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15886 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15888 salt
->salt_len
= salt_len
;
15892 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15894 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15895 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15896 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15897 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15898 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15900 return (PARSER_OK
);
15903 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15905 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15907 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15909 salt_t
*salt
= hash_buf
->salt
;
15911 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15912 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15913 digest
[2] = hex_to_uint (&input_buf
[16]);
15914 digest
[3] = hex_to_uint (&input_buf
[24]);
15915 digest
[4] = hex_to_uint (&input_buf
[32]);
15917 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15919 uint salt_len
= input_len
- 40 - 1;
15921 char *salt_buf
= input_buf
+ 40 + 1;
15923 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15925 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15927 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15929 salt
->salt_len
= salt_len
;
15931 return (PARSER_OK
);
15934 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15936 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15938 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15940 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15942 salt_t
*salt
= hash_buf
->salt
;
15944 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15950 char *V_pos
= input_buf
+ 5;
15952 char *R_pos
= strchr (V_pos
, '*');
15954 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15956 uint32_t V_len
= R_pos
- V_pos
;
15960 char *bits_pos
= strchr (R_pos
, '*');
15962 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15964 uint32_t R_len
= bits_pos
- R_pos
;
15968 char *P_pos
= strchr (bits_pos
, '*');
15970 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15972 uint32_t bits_len
= P_pos
- bits_pos
;
15976 char *enc_md_pos
= strchr (P_pos
, '*');
15978 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15980 uint32_t P_len
= enc_md_pos
- P_pos
;
15984 char *id_len_pos
= strchr (enc_md_pos
, '*');
15986 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15988 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
15992 char *id_buf_pos
= strchr (id_len_pos
, '*');
15994 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15996 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16000 char *u_len_pos
= strchr (id_buf_pos
, '*');
16002 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16004 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16006 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16010 char *u_buf_pos
= strchr (u_len_pos
, '*');
16012 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16014 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16018 char *o_len_pos
= strchr (u_buf_pos
, '*');
16020 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16022 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16024 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16028 char *o_buf_pos
= strchr (o_len_pos
, '*');
16030 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16032 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16036 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;
16038 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16042 const int V
= atoi (V_pos
);
16043 const int R
= atoi (R_pos
);
16044 const int P
= atoi (P_pos
);
16046 if (V
!= 1) return (PARSER_SALT_VALUE
);
16047 if (R
!= 2) return (PARSER_SALT_VALUE
);
16049 const int enc_md
= atoi (enc_md_pos
);
16051 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16053 const int id_len
= atoi (id_len_pos
);
16054 const int u_len
= atoi (u_len_pos
);
16055 const int o_len
= atoi (o_len_pos
);
16057 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16058 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16059 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16061 const int bits
= atoi (bits_pos
);
16063 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16065 // copy data to esalt
16071 pdf
->enc_md
= enc_md
;
16073 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16074 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16075 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16076 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16077 pdf
->id_len
= id_len
;
16079 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16080 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16081 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16082 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16083 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16084 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16085 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16086 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16087 pdf
->u_len
= u_len
;
16089 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16090 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16091 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16092 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16093 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16094 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16095 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16096 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16097 pdf
->o_len
= o_len
;
16099 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16100 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16101 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16102 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16104 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16105 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16106 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16107 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16108 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16109 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16110 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16111 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16113 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16114 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16115 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16116 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16117 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16118 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16119 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16120 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16122 // we use ID for salt, maybe needs to change, we will see...
16124 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16125 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16126 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16127 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16128 salt
->salt_len
= pdf
->id_len
;
16130 digest
[0] = pdf
->u_buf
[0];
16131 digest
[1] = pdf
->u_buf
[1];
16132 digest
[2] = pdf
->u_buf
[2];
16133 digest
[3] = pdf
->u_buf
[3];
16135 return (PARSER_OK
);
16138 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16140 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16143 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16145 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16147 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16149 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16151 salt_t
*salt
= hash_buf
->salt
;
16153 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16159 char *V_pos
= input_buf
+ 5;
16161 char *R_pos
= strchr (V_pos
, '*');
16163 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16165 uint32_t V_len
= R_pos
- V_pos
;
16169 char *bits_pos
= strchr (R_pos
, '*');
16171 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16173 uint32_t R_len
= bits_pos
- R_pos
;
16177 char *P_pos
= strchr (bits_pos
, '*');
16179 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16181 uint32_t bits_len
= P_pos
- bits_pos
;
16185 char *enc_md_pos
= strchr (P_pos
, '*');
16187 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16189 uint32_t P_len
= enc_md_pos
- P_pos
;
16193 char *id_len_pos
= strchr (enc_md_pos
, '*');
16195 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16197 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16201 char *id_buf_pos
= strchr (id_len_pos
, '*');
16203 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16205 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16209 char *u_len_pos
= strchr (id_buf_pos
, '*');
16211 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16213 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16215 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16219 char *u_buf_pos
= strchr (u_len_pos
, '*');
16221 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16223 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16227 char *o_len_pos
= strchr (u_buf_pos
, '*');
16229 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16231 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16233 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16237 char *o_buf_pos
= strchr (o_len_pos
, '*');
16239 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16241 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16245 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16247 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16249 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16251 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16255 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;
16257 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16261 const int V
= atoi (V_pos
);
16262 const int R
= atoi (R_pos
);
16263 const int P
= atoi (P_pos
);
16265 if (V
!= 1) return (PARSER_SALT_VALUE
);
16266 if (R
!= 2) return (PARSER_SALT_VALUE
);
16268 const int enc_md
= atoi (enc_md_pos
);
16270 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16272 const int id_len
= atoi (id_len_pos
);
16273 const int u_len
= atoi (u_len_pos
);
16274 const int o_len
= atoi (o_len_pos
);
16276 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16277 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16278 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16280 const int bits
= atoi (bits_pos
);
16282 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16284 // copy data to esalt
16290 pdf
->enc_md
= enc_md
;
16292 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16293 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16294 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16295 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16296 pdf
->id_len
= id_len
;
16298 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16299 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16300 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16301 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16302 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16303 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16304 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16305 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16306 pdf
->u_len
= u_len
;
16308 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16309 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16310 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16311 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16312 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16313 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16314 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16315 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16316 pdf
->o_len
= o_len
;
16318 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16319 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16320 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16321 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16323 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16324 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16325 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16326 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16327 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16328 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16329 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16330 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16332 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16333 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16334 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16335 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16336 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16337 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16338 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16339 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16341 pdf
->rc4key
[1] = 0;
16342 pdf
->rc4key
[0] = 0;
16344 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16345 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16346 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16347 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16348 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16349 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16350 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16351 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16352 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16353 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16355 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16356 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16358 // we use ID for salt, maybe needs to change, we will see...
16360 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16361 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16362 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16363 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16364 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16365 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16366 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16367 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16368 salt
->salt_len
= pdf
->id_len
+ 16;
16370 digest
[0] = pdf
->rc4key
[0];
16371 digest
[1] = pdf
->rc4key
[1];
16375 return (PARSER_OK
);
16378 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16380 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16382 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16384 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16386 salt_t
*salt
= hash_buf
->salt
;
16388 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16394 char *V_pos
= input_buf
+ 5;
16396 char *R_pos
= strchr (V_pos
, '*');
16398 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16400 uint32_t V_len
= R_pos
- V_pos
;
16404 char *bits_pos
= strchr (R_pos
, '*');
16406 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16408 uint32_t R_len
= bits_pos
- R_pos
;
16412 char *P_pos
= strchr (bits_pos
, '*');
16414 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16416 uint32_t bits_len
= P_pos
- bits_pos
;
16420 char *enc_md_pos
= strchr (P_pos
, '*');
16422 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16424 uint32_t P_len
= enc_md_pos
- P_pos
;
16428 char *id_len_pos
= strchr (enc_md_pos
, '*');
16430 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16432 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16436 char *id_buf_pos
= strchr (id_len_pos
, '*');
16438 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16440 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16444 char *u_len_pos
= strchr (id_buf_pos
, '*');
16446 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16448 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16450 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16454 char *u_buf_pos
= strchr (u_len_pos
, '*');
16456 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16458 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16462 char *o_len_pos
= strchr (u_buf_pos
, '*');
16464 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16466 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16468 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16472 char *o_buf_pos
= strchr (o_len_pos
, '*');
16474 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16476 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16480 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;
16482 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16486 const int V
= atoi (V_pos
);
16487 const int R
= atoi (R_pos
);
16488 const int P
= atoi (P_pos
);
16492 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16493 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16495 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16497 const int id_len
= atoi (id_len_pos
);
16498 const int u_len
= atoi (u_len_pos
);
16499 const int o_len
= atoi (o_len_pos
);
16501 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16503 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16504 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16506 const int bits
= atoi (bits_pos
);
16508 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16514 enc_md
= atoi (enc_md_pos
);
16517 // copy data to esalt
16523 pdf
->enc_md
= enc_md
;
16525 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16526 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16527 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16528 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16532 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16533 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16534 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16535 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16538 pdf
->id_len
= id_len
;
16540 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16541 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16542 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16543 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16544 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16545 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16546 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16547 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16548 pdf
->u_len
= u_len
;
16550 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16551 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16552 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16553 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16554 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16555 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16556 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16557 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16558 pdf
->o_len
= o_len
;
16560 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16561 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16562 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16563 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16567 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16568 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16569 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16570 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16573 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16574 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16575 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16576 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16577 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16578 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16579 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16580 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16582 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16583 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16584 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16585 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16586 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16587 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16588 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16589 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16591 // precompute rc4 data for later use
16607 uint salt_pc_block
[32];
16609 char *salt_pc_ptr
= (char *) salt_pc_block
;
16611 memcpy (salt_pc_ptr
, padding
, 32);
16612 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16614 uint salt_pc_digest
[4];
16616 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16618 pdf
->rc4data
[0] = salt_pc_digest
[0];
16619 pdf
->rc4data
[1] = salt_pc_digest
[1];
16621 // we use ID for salt, maybe needs to change, we will see...
16623 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16624 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16625 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16626 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16627 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16628 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16629 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16630 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16631 salt
->salt_len
= pdf
->id_len
+ 16;
16633 salt
->salt_iter
= ROUNDS_PDF14
;
16635 digest
[0] = pdf
->u_buf
[0];
16636 digest
[1] = pdf
->u_buf
[1];
16640 return (PARSER_OK
);
16643 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16645 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16647 if (ret
!= PARSER_OK
)
16652 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16654 salt_t
*salt
= hash_buf
->salt
;
16656 digest
[0] -= SHA256M_A
;
16657 digest
[1] -= SHA256M_B
;
16658 digest
[2] -= SHA256M_C
;
16659 digest
[3] -= SHA256M_D
;
16660 digest
[4] -= SHA256M_E
;
16661 digest
[5] -= SHA256M_F
;
16662 digest
[6] -= SHA256M_G
;
16663 digest
[7] -= SHA256M_H
;
16665 salt
->salt_buf
[2] = 0x80;
16667 return (PARSER_OK
);
16670 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16672 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16674 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16676 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16678 salt_t
*salt
= hash_buf
->salt
;
16680 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16686 char *V_pos
= input_buf
+ 5;
16688 char *R_pos
= strchr (V_pos
, '*');
16690 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16692 uint32_t V_len
= R_pos
- V_pos
;
16696 char *bits_pos
= strchr (R_pos
, '*');
16698 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16700 uint32_t R_len
= bits_pos
- R_pos
;
16704 char *P_pos
= strchr (bits_pos
, '*');
16706 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16708 uint32_t bits_len
= P_pos
- bits_pos
;
16712 char *enc_md_pos
= strchr (P_pos
, '*');
16714 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16716 uint32_t P_len
= enc_md_pos
- P_pos
;
16720 char *id_len_pos
= strchr (enc_md_pos
, '*');
16722 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16724 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16728 char *id_buf_pos
= strchr (id_len_pos
, '*');
16730 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16732 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16736 char *u_len_pos
= strchr (id_buf_pos
, '*');
16738 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16740 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16744 char *u_buf_pos
= strchr (u_len_pos
, '*');
16746 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16748 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16752 char *o_len_pos
= strchr (u_buf_pos
, '*');
16754 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16756 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16760 char *o_buf_pos
= strchr (o_len_pos
, '*');
16762 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16764 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16768 char *last
= strchr (o_buf_pos
, '*');
16770 if (last
== NULL
) last
= input_buf
+ input_len
;
16772 uint32_t o_buf_len
= last
- o_buf_pos
;
16776 const int V
= atoi (V_pos
);
16777 const int R
= atoi (R_pos
);
16781 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16782 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16784 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16786 const int bits
= atoi (bits_pos
);
16788 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16790 int enc_md
= atoi (enc_md_pos
);
16792 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16794 const uint id_len
= atoi (id_len_pos
);
16795 const uint u_len
= atoi (u_len_pos
);
16796 const uint o_len
= atoi (o_len_pos
);
16798 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16799 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16800 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16801 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16802 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16803 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16804 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16805 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16807 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16808 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16809 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16811 // copy data to esalt
16813 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16815 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16817 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16820 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16821 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16823 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16824 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16826 salt
->salt_len
= 8;
16827 salt
->salt_iter
= ROUNDS_PDF17L8
;
16829 digest
[0] = pdf
->u_buf
[0];
16830 digest
[1] = pdf
->u_buf
[1];
16831 digest
[2] = pdf
->u_buf
[2];
16832 digest
[3] = pdf
->u_buf
[3];
16833 digest
[4] = pdf
->u_buf
[4];
16834 digest
[5] = pdf
->u_buf
[5];
16835 digest
[6] = pdf
->u_buf
[6];
16836 digest
[7] = pdf
->u_buf
[7];
16838 return (PARSER_OK
);
16841 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16843 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16845 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16847 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16849 salt_t
*salt
= hash_buf
->salt
;
16851 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16859 char *iter_pos
= input_buf
+ 7;
16861 uint32_t iter
= atoi (iter_pos
);
16863 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16864 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16866 // first is *raw* salt
16868 char *salt_pos
= strchr (iter_pos
, ':');
16870 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16874 char *hash_pos
= strchr (salt_pos
, ':');
16876 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16878 uint32_t salt_len
= hash_pos
- salt_pos
;
16880 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16884 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16886 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16890 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16892 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16894 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16896 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16897 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16899 salt
->salt_len
= salt_len
;
16900 salt
->salt_iter
= iter
- 1;
16906 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16908 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16910 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16912 memcpy (digest
, tmp_buf
, 16);
16914 digest
[0] = byte_swap_32 (digest
[0]);
16915 digest
[1] = byte_swap_32 (digest
[1]);
16916 digest
[2] = byte_swap_32 (digest
[2]);
16917 digest
[3] = byte_swap_32 (digest
[3]);
16919 // add some stuff to normal salt to make sorted happy
16921 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16922 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16923 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16924 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16925 salt
->salt_buf
[4] = salt
->salt_iter
;
16927 return (PARSER_OK
);
16930 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16932 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16934 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16936 salt_t
*salt
= hash_buf
->salt
;
16938 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16939 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16940 digest
[2] = hex_to_uint (&input_buf
[16]);
16941 digest
[3] = hex_to_uint (&input_buf
[24]);
16943 digest
[0] = byte_swap_32 (digest
[0]);
16944 digest
[1] = byte_swap_32 (digest
[1]);
16945 digest
[2] = byte_swap_32 (digest
[2]);
16946 digest
[3] = byte_swap_32 (digest
[3]);
16948 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16950 uint salt_len
= input_len
- 32 - 1;
16952 char *salt_buf
= input_buf
+ 32 + 1;
16954 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16956 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16958 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16960 salt
->salt_len
= salt_len
;
16962 return (PARSER_OK
);
16965 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16967 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
16969 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16971 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16973 salt_t
*salt
= hash_buf
->salt
;
16975 char *user_pos
= input_buf
+ 10;
16977 char *salt_pos
= strchr (user_pos
, '*');
16979 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16983 char *hash_pos
= strchr (salt_pos
, '*');
16987 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16989 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
16991 uint user_len
= salt_pos
- user_pos
- 1;
16993 uint salt_len
= hash_pos
- salt_pos
- 1;
16995 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17001 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17002 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17003 digest
[2] = hex_to_uint (&hash_pos
[16]);
17004 digest
[3] = hex_to_uint (&hash_pos
[24]);
17006 digest
[0] = byte_swap_32 (digest
[0]);
17007 digest
[1] = byte_swap_32 (digest
[1]);
17008 digest
[2] = byte_swap_32 (digest
[2]);
17009 digest
[3] = byte_swap_32 (digest
[3]);
17011 digest
[0] -= MD5M_A
;
17012 digest
[1] -= MD5M_B
;
17013 digest
[2] -= MD5M_C
;
17014 digest
[3] -= MD5M_D
;
17020 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17022 // first 4 bytes are the "challenge"
17024 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17025 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17026 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17027 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17029 // append the user name
17031 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17033 salt
->salt_len
= 4 + user_len
;
17035 return (PARSER_OK
);
17038 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17040 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17042 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17044 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17046 salt_t
*salt
= hash_buf
->salt
;
17048 char *salt_pos
= input_buf
+ 9;
17050 char *hash_pos
= strchr (salt_pos
, '*');
17052 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17056 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17058 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17060 uint salt_len
= hash_pos
- salt_pos
- 1;
17062 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17068 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17069 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17070 digest
[2] = hex_to_uint (&hash_pos
[16]);
17071 digest
[3] = hex_to_uint (&hash_pos
[24]);
17072 digest
[4] = hex_to_uint (&hash_pos
[32]);
17078 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17080 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17082 salt
->salt_len
= salt_len
;
17084 return (PARSER_OK
);
17087 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17089 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17091 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17093 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17095 salt_t
*salt
= hash_buf
->salt
;
17097 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17103 char *cry_master_len_pos
= input_buf
+ 9;
17105 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17107 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17109 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17111 cry_master_buf_pos
++;
17113 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17115 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17119 cry_salt_len_pos
++;
17121 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17123 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17125 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17127 cry_salt_buf_pos
++;
17129 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17131 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17137 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17139 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17145 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17147 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17153 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17155 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17157 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17159 public_key_len_pos
++;
17161 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17163 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17167 public_key_buf_pos
++;
17169 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;
17171 const uint cry_master_len
= atoi (cry_master_len_pos
);
17172 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17173 const uint ckey_len
= atoi (ckey_len_pos
);
17174 const uint public_key_len
= atoi (public_key_len_pos
);
17176 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17177 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17178 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17179 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17181 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17183 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17185 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17188 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17190 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17192 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17195 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17197 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17199 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17202 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17203 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17204 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17207 * store digest (should be unique enought, hopefully)
17210 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17211 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17212 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17213 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17219 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17221 const uint cry_rounds
= atoi (cry_rounds_pos
);
17223 salt
->salt_iter
= cry_rounds
- 1;
17225 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17227 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17229 salt
->salt_len
= salt_len
;
17231 return (PARSER_OK
);
17234 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17236 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17238 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17240 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17242 salt_t
*salt
= hash_buf
->salt
;
17244 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17246 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17248 char temp_input_buf
[input_len
+ 1];
17250 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17251 memcpy (temp_input_buf
, input_buf
, input_len
);
17255 char *URI_server_pos
= temp_input_buf
+ 6;
17257 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17259 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 URI_client_pos
[0] = 0;
17264 uint URI_server_len
= strlen (URI_server_pos
);
17266 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17270 char *user_pos
= strchr (URI_client_pos
, '*');
17272 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17277 uint URI_client_len
= strlen (URI_client_pos
);
17279 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17283 char *realm_pos
= strchr (user_pos
, '*');
17285 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17290 uint user_len
= strlen (user_pos
);
17292 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17296 char *method_pos
= strchr (realm_pos
, '*');
17298 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17303 uint realm_len
= strlen (realm_pos
);
17305 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17309 char *URI_prefix_pos
= strchr (method_pos
, '*');
17311 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17313 URI_prefix_pos
[0] = 0;
17316 uint method_len
= strlen (method_pos
);
17318 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17322 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17324 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17326 URI_resource_pos
[0] = 0;
17327 URI_resource_pos
++;
17329 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17331 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17335 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17337 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17339 URI_suffix_pos
[0] = 0;
17342 uint URI_resource_len
= strlen (URI_resource_pos
);
17344 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17345 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17349 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17351 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17356 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17358 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17362 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17364 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17366 nonce_client_pos
[0] = 0;
17367 nonce_client_pos
++;
17369 uint nonce_len
= strlen (nonce_pos
);
17371 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17372 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17376 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17378 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17380 nonce_count_pos
[0] = 0;
17383 uint nonce_client_len
= strlen (nonce_client_pos
);
17385 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17389 char *qop_pos
= strchr (nonce_count_pos
, '*');
17391 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17396 uint nonce_count_len
= strlen (nonce_count_pos
);
17398 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17402 char *directive_pos
= strchr (qop_pos
, '*');
17404 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17406 directive_pos
[0] = 0;
17409 uint qop_len
= strlen (qop_pos
);
17411 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17415 char *digest_pos
= strchr (directive_pos
, '*');
17417 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17422 uint directive_len
= strlen (directive_pos
);
17424 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17426 if (memcmp (directive_pos
, "MD5", 3))
17428 log_info ("ERROR: only the MD5 directive is currently supported\n");
17430 return (PARSER_SIP_AUTH_DIRECTIVE
);
17434 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17439 uint md5_max_len
= 4 * 64;
17441 uint md5_remaining_len
= md5_max_len
;
17443 uint tmp_md5_buf
[md5_max_len
/ 4];
17445 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17447 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17449 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17451 md5_len
+= method_len
+ 1;
17452 tmp_md5_ptr
+= method_len
+ 1;
17454 if (URI_prefix_len
> 0)
17456 md5_remaining_len
= md5_max_len
- md5_len
;
17458 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17460 md5_len
+= URI_prefix_len
+ 1;
17461 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17464 md5_remaining_len
= md5_max_len
- md5_len
;
17466 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17468 md5_len
+= URI_resource_len
;
17469 tmp_md5_ptr
+= URI_resource_len
;
17471 if (URI_suffix_len
> 0)
17473 md5_remaining_len
= md5_max_len
- md5_len
;
17475 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17477 md5_len
+= 1 + URI_suffix_len
;
17480 uint tmp_digest
[4];
17482 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17484 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17485 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17486 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17487 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17493 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17495 uint esalt_len
= 0;
17497 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17499 // there are 2 possibilities for the esalt:
17501 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17503 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17505 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17507 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17519 esalt_len
= 1 + nonce_len
+ 1 + 32;
17521 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17523 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17531 // add 0x80 to esalt
17533 esalt_buf_ptr
[esalt_len
] = 0x80;
17535 sip
->esalt_len
= esalt_len
;
17541 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17543 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17545 uint max_salt_len
= 119;
17547 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17549 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17551 sip
->salt_len
= salt_len
;
17554 * fake salt (for sorting)
17557 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17561 uint fake_salt_len
= salt_len
;
17563 if (fake_salt_len
> max_salt_len
)
17565 fake_salt_len
= max_salt_len
;
17568 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17570 salt
->salt_len
= fake_salt_len
;
17576 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17577 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17578 digest
[2] = hex_to_uint (&digest_pos
[16]);
17579 digest
[3] = hex_to_uint (&digest_pos
[24]);
17581 digest
[0] = byte_swap_32 (digest
[0]);
17582 digest
[1] = byte_swap_32 (digest
[1]);
17583 digest
[2] = byte_swap_32 (digest
[2]);
17584 digest
[3] = byte_swap_32 (digest
[3]);
17586 return (PARSER_OK
);
17589 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17591 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17593 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17595 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17597 salt_t
*salt
= hash_buf
->salt
;
17601 char *digest_pos
= input_buf
;
17603 digest
[0] = hex_to_uint (&digest_pos
[0]);
17610 char *salt_buf
= input_buf
+ 8 + 1;
17614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17616 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17620 salt
->salt_len
= salt_len
;
17622 return (PARSER_OK
);
17625 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17627 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17629 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17631 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17633 salt_t
*salt
= hash_buf
->salt
;
17635 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17641 char *p_buf_pos
= input_buf
+ 4;
17643 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17645 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17647 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17649 NumCyclesPower_pos
++;
17651 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17653 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17655 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17659 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17661 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17663 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17667 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17669 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17671 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17675 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17677 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17679 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17683 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17685 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17687 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17691 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17693 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17695 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17699 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17701 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17703 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17707 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17709 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17711 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17715 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;
17717 const uint iter
= atoi (NumCyclesPower_pos
);
17718 const uint crc
= atoi (crc_buf_pos
);
17719 const uint p_buf
= atoi (p_buf_pos
);
17720 const uint salt_len
= atoi (salt_len_pos
);
17721 const uint iv_len
= atoi (iv_len_pos
);
17722 const uint unpack_size
= atoi (unpack_size_pos
);
17723 const uint data_len
= atoi (data_len_pos
);
17729 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17730 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17732 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17734 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17736 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17742 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17743 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17744 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17745 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17747 seven_zip
->iv_len
= iv_len
;
17749 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17751 seven_zip
->salt_len
= 0;
17753 seven_zip
->crc
= crc
;
17755 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17757 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17759 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17762 seven_zip
->data_len
= data_len
;
17764 seven_zip
->unpack_size
= unpack_size
;
17768 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17769 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17770 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17771 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17773 salt
->salt_len
= 16;
17775 salt
->salt_sign
[0] = iter
;
17777 salt
->salt_iter
= 1 << iter
;
17788 return (PARSER_OK
);
17791 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17793 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17795 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17797 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17798 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17799 digest
[2] = hex_to_uint (&input_buf
[16]);
17800 digest
[3] = hex_to_uint (&input_buf
[24]);
17801 digest
[4] = hex_to_uint (&input_buf
[32]);
17802 digest
[5] = hex_to_uint (&input_buf
[40]);
17803 digest
[6] = hex_to_uint (&input_buf
[48]);
17804 digest
[7] = hex_to_uint (&input_buf
[56]);
17806 digest
[0] = byte_swap_32 (digest
[0]);
17807 digest
[1] = byte_swap_32 (digest
[1]);
17808 digest
[2] = byte_swap_32 (digest
[2]);
17809 digest
[3] = byte_swap_32 (digest
[3]);
17810 digest
[4] = byte_swap_32 (digest
[4]);
17811 digest
[5] = byte_swap_32 (digest
[5]);
17812 digest
[6] = byte_swap_32 (digest
[6]);
17813 digest
[7] = byte_swap_32 (digest
[7]);
17815 return (PARSER_OK
);
17818 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17820 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17822 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17824 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17825 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17826 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17827 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17828 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17829 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17830 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17831 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17832 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17833 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17834 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17835 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17836 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17837 digest
[13] = hex_to_uint (&input_buf
[104]);
17838 digest
[14] = hex_to_uint (&input_buf
[112]);
17839 digest
[15] = hex_to_uint (&input_buf
[120]);
17841 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17842 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17843 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17844 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17845 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17846 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17847 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17848 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17849 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17850 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17851 digest
[10] = byte_swap_32 (digest
[10]);
17852 digest
[11] = byte_swap_32 (digest
[11]);
17853 digest
[12] = byte_swap_32 (digest
[12]);
17854 digest
[13] = byte_swap_32 (digest
[13]);
17855 digest
[14] = byte_swap_32 (digest
[14]);
17856 digest
[15] = byte_swap_32 (digest
[15]);
17858 return (PARSER_OK
);
17861 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17863 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17865 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17867 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17869 salt_t
*salt
= hash_buf
->salt
;
17871 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17879 char *iter_pos
= input_buf
+ 4;
17881 uint32_t iter
= atoi (iter_pos
);
17883 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17884 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17886 // first is *raw* salt
17888 char *salt_pos
= strchr (iter_pos
, ':');
17890 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17894 char *hash_pos
= strchr (salt_pos
, ':');
17896 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17898 uint32_t salt_len
= hash_pos
- salt_pos
;
17900 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17904 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17906 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17910 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17912 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17914 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17916 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17917 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17919 salt
->salt_len
= salt_len
;
17920 salt
->salt_iter
= iter
- 1;
17926 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17928 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17930 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17932 memcpy (digest
, tmp_buf
, 16);
17934 // add some stuff to normal salt to make sorted happy
17936 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17937 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17938 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17939 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17940 salt
->salt_buf
[4] = salt
->salt_iter
;
17942 return (PARSER_OK
);
17945 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17947 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17949 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17951 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17953 salt_t
*salt
= hash_buf
->salt
;
17955 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
17963 char *iter_pos
= input_buf
+ 5;
17965 uint32_t iter
= atoi (iter_pos
);
17967 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17968 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17970 // first is *raw* salt
17972 char *salt_pos
= strchr (iter_pos
, ':');
17974 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17978 char *hash_pos
= strchr (salt_pos
, ':');
17980 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17982 uint32_t salt_len
= hash_pos
- salt_pos
;
17984 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17988 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17990 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17994 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
17996 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17998 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18000 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18001 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18003 salt
->salt_len
= salt_len
;
18004 salt
->salt_iter
= iter
- 1;
18010 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18012 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18014 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18016 memcpy (digest
, tmp_buf
, 16);
18018 digest
[0] = byte_swap_32 (digest
[0]);
18019 digest
[1] = byte_swap_32 (digest
[1]);
18020 digest
[2] = byte_swap_32 (digest
[2]);
18021 digest
[3] = byte_swap_32 (digest
[3]);
18023 // add some stuff to normal salt to make sorted happy
18025 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18026 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18027 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18028 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18029 salt
->salt_buf
[4] = salt
->salt_iter
;
18031 return (PARSER_OK
);
18034 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18036 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18038 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18040 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18042 salt_t
*salt
= hash_buf
->salt
;
18044 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18052 char *iter_pos
= input_buf
+ 7;
18054 uint32_t iter
= atoi (iter_pos
);
18056 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18057 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18059 // first is *raw* salt
18061 char *salt_pos
= strchr (iter_pos
, ':');
18063 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18067 char *hash_pos
= strchr (salt_pos
, ':');
18069 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18071 uint32_t salt_len
= hash_pos
- salt_pos
;
18073 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18077 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18079 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18083 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18085 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18087 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18089 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18090 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18092 salt
->salt_len
= salt_len
;
18093 salt
->salt_iter
= iter
- 1;
18099 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18101 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18103 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18105 memcpy (digest
, tmp_buf
, 64);
18107 digest
[0] = byte_swap_64 (digest
[0]);
18108 digest
[1] = byte_swap_64 (digest
[1]);
18109 digest
[2] = byte_swap_64 (digest
[2]);
18110 digest
[3] = byte_swap_64 (digest
[3]);
18111 digest
[4] = byte_swap_64 (digest
[4]);
18112 digest
[5] = byte_swap_64 (digest
[5]);
18113 digest
[6] = byte_swap_64 (digest
[6]);
18114 digest
[7] = byte_swap_64 (digest
[7]);
18116 // add some stuff to normal salt to make sorted happy
18118 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18119 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18120 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18121 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18122 salt
->salt_buf
[4] = salt
->salt_iter
;
18124 return (PARSER_OK
);
18127 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18129 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18131 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18133 uint
*digest
= (uint
*) hash_buf
->digest
;
18135 salt_t
*salt
= hash_buf
->salt
;
18141 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18143 char *hash_pos
= strchr (salt_pos
, '$');
18145 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18147 uint32_t salt_len
= hash_pos
- salt_pos
;
18149 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18153 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18155 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18159 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18160 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18178 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18179 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18181 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18182 salt
->salt_len
= 8;
18184 return (PARSER_OK
);
18187 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18189 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18191 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18193 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18195 if (c19
& 3) return (PARSER_HASH_VALUE
);
18197 salt_t
*salt
= hash_buf
->salt
;
18199 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18203 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18204 | itoa64_to_int (input_buf
[2]) << 6
18205 | itoa64_to_int (input_buf
[3]) << 12
18206 | itoa64_to_int (input_buf
[4]) << 18;
18210 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18211 | itoa64_to_int (input_buf
[6]) << 6
18212 | itoa64_to_int (input_buf
[7]) << 12
18213 | itoa64_to_int (input_buf
[8]) << 18;
18215 salt
->salt_len
= 4;
18219 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18221 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18223 memcpy (digest
, tmp_buf
, 8);
18227 IP (digest
[0], digest
[1], tt
);
18229 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18230 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18234 return (PARSER_OK
);
18237 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18239 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18241 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18243 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18245 salt_t
*salt
= hash_buf
->salt
;
18251 char *type_pos
= input_buf
+ 6 + 1;
18253 char *salt_pos
= strchr (type_pos
, '*');
18255 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18257 uint32_t type_len
= salt_pos
- type_pos
;
18259 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18263 char *crypted_pos
= strchr (salt_pos
, '*');
18265 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18267 uint32_t salt_len
= crypted_pos
- salt_pos
;
18269 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18273 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18275 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18281 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18282 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18284 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18285 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18287 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18288 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18289 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18290 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18292 salt
->salt_len
= 24;
18293 salt
->salt_iter
= ROUNDS_RAR3
;
18295 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18296 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18298 digest
[0] = 0xc43d7b00;
18299 digest
[1] = 0x40070000;
18303 return (PARSER_OK
);
18306 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18308 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18310 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18312 salt_t
*salt
= hash_buf
->salt
;
18314 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18315 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18316 digest
[2] = hex_to_uint (&input_buf
[16]);
18317 digest
[3] = hex_to_uint (&input_buf
[24]);
18318 digest
[4] = hex_to_uint (&input_buf
[32]);
18319 digest
[5] = hex_to_uint (&input_buf
[40]);
18320 digest
[6] = hex_to_uint (&input_buf
[48]);
18321 digest
[7] = hex_to_uint (&input_buf
[56]);
18323 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18325 uint salt_len
= input_len
- 64 - 1;
18327 char *salt_buf
= input_buf
+ 64 + 1;
18329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18335 salt
->salt_len
= salt_len
;
18338 * we can precompute the first sha256 transform
18343 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18344 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18345 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18346 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18347 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18348 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18349 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18350 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18351 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18352 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18353 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18354 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18355 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18356 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18357 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18358 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18362 pc256
[0] = SHA256M_A
;
18363 pc256
[1] = SHA256M_B
;
18364 pc256
[2] = SHA256M_C
;
18365 pc256
[3] = SHA256M_D
;
18366 pc256
[4] = SHA256M_E
;
18367 pc256
[5] = SHA256M_F
;
18368 pc256
[6] = SHA256M_G
;
18369 pc256
[7] = SHA256M_H
;
18371 sha256_64 (w
, pc256
);
18373 salt
->salt_buf_pc
[0] = pc256
[0];
18374 salt
->salt_buf_pc
[1] = pc256
[1];
18375 salt
->salt_buf_pc
[2] = pc256
[2];
18376 salt
->salt_buf_pc
[3] = pc256
[3];
18377 salt
->salt_buf_pc
[4] = pc256
[4];
18378 salt
->salt_buf_pc
[5] = pc256
[5];
18379 salt
->salt_buf_pc
[6] = pc256
[6];
18380 salt
->salt_buf_pc
[7] = pc256
[7];
18382 digest
[0] -= pc256
[0];
18383 digest
[1] -= pc256
[1];
18384 digest
[2] -= pc256
[2];
18385 digest
[3] -= pc256
[3];
18386 digest
[4] -= pc256
[4];
18387 digest
[5] -= pc256
[5];
18388 digest
[6] -= pc256
[6];
18389 digest
[7] -= pc256
[7];
18391 return (PARSER_OK
);
18394 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18396 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18398 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18400 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18402 salt_t
*salt
= hash_buf
->salt
;
18408 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18410 char *data_buf_pos
= strchr (data_len_pos
, '$');
18412 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18414 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18416 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18417 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18421 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18423 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18425 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18427 uint32_t data_len
= atoi (data_len_pos
);
18429 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18435 char *salt_pos
= data_buf_pos
;
18437 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18438 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18439 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18440 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18442 // this is actually the CT, which is also the hash later (if matched)
18444 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18445 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18446 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18447 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18449 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18451 salt
->salt_iter
= 10 - 1;
18457 digest
[0] = salt
->salt_buf
[4];
18458 digest
[1] = salt
->salt_buf
[5];
18459 digest
[2] = salt
->salt_buf
[6];
18460 digest
[3] = salt
->salt_buf
[7];
18462 return (PARSER_OK
);
18465 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18467 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18469 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18471 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18473 salt_t
*salt
= hash_buf
->salt
;
18479 char *salt_pos
= input_buf
+ 11 + 1;
18481 char *iter_pos
= strchr (salt_pos
, ',');
18483 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18485 uint32_t salt_len
= iter_pos
- salt_pos
;
18487 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18491 char *hash_pos
= strchr (iter_pos
, ',');
18493 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18495 uint32_t iter_len
= hash_pos
- iter_pos
;
18497 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18501 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18503 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18509 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18510 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18511 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18512 salt
->salt_buf
[3] = 0x00018000;
18514 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18515 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18516 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18517 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18519 salt
->salt_len
= salt_len
/ 2;
18521 salt
->salt_iter
= atoi (iter_pos
) - 1;
18527 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18528 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18529 digest
[2] = hex_to_uint (&hash_pos
[16]);
18530 digest
[3] = hex_to_uint (&hash_pos
[24]);
18531 digest
[4] = hex_to_uint (&hash_pos
[32]);
18532 digest
[5] = hex_to_uint (&hash_pos
[40]);
18533 digest
[6] = hex_to_uint (&hash_pos
[48]);
18534 digest
[7] = hex_to_uint (&hash_pos
[56]);
18536 return (PARSER_OK
);
18540 * parallel running threads
18545 BOOL WINAPI
sigHandler_default (DWORD sig
)
18549 case CTRL_CLOSE_EVENT
:
18552 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18553 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18554 * function otherwise it is to late (e.g. after returning from this function)
18559 SetConsoleCtrlHandler (NULL
, TRUE
);
18566 case CTRL_LOGOFF_EVENT
:
18567 case CTRL_SHUTDOWN_EVENT
:
18571 SetConsoleCtrlHandler (NULL
, TRUE
);
18579 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18583 case CTRL_CLOSE_EVENT
:
18587 SetConsoleCtrlHandler (NULL
, TRUE
);
18594 case CTRL_LOGOFF_EVENT
:
18595 case CTRL_SHUTDOWN_EVENT
:
18599 SetConsoleCtrlHandler (NULL
, TRUE
);
18607 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18609 if (callback
== NULL
)
18611 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18615 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18621 void sigHandler_default (int sig
)
18625 signal (sig
, NULL
);
18628 void sigHandler_benchmark (int sig
)
18632 signal (sig
, NULL
);
18635 void hc_signal (void (callback
) (int))
18637 if (callback
== NULL
) callback
= SIG_DFL
;
18639 signal (SIGINT
, callback
);
18640 signal (SIGTERM
, callback
);
18641 signal (SIGABRT
, callback
);
18646 void status_display ();
18648 void *thread_keypress (void *p
)
18650 int benchmark
= *((int *) p
);
18652 uint quiet
= data
.quiet
;
18656 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18658 int ch
= tty_getchar();
18660 if (ch
== -1) break;
18662 if (ch
== 0) continue;
18668 hc_thread_mutex_lock (mux_display
);
18683 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18684 if (quiet
== 0) fflush (stdout
);
18696 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18697 if (quiet
== 0) fflush (stdout
);
18709 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18710 if (quiet
== 0) fflush (stdout
);
18722 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18723 if (quiet
== 0) fflush (stdout
);
18731 if (benchmark
== 1) break;
18733 stop_at_checkpoint ();
18737 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18738 if (quiet
== 0) fflush (stdout
);
18746 if (benchmark
== 1)
18758 hc_thread_mutex_unlock (mux_display
);
18770 bool class_num (char c
)
18772 return ((c
>= '0') && (c
<= '9'));
18775 bool class_lower (char c
)
18777 return ((c
>= 'a') && (c
<= 'z'));
18780 bool class_upper (char c
)
18782 return ((c
>= 'A') && (c
<= 'Z'));
18785 bool class_alpha (char c
)
18787 return (class_lower (c
) || class_upper (c
));
18790 char conv_ctoi (char c
)
18796 else if (class_upper (c
))
18798 return c
- 'A' + (char) 10;
18801 return (char) (-1);
18804 char conv_itoc (char c
)
18812 return c
+ 'A' - (char) 10;
18815 return (char) (-1);
18822 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18823 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18824 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18825 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18826 #define MAX_GPU_RULES 14
18827 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18828 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18829 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18831 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18832 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18833 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18834 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18836 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18841 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18843 switch (rule_buf
[rule_pos
])
18849 case RULE_OP_MANGLE_NOOP
:
18850 SET_NAME (rule
, rule_buf
[rule_pos
]);
18853 case RULE_OP_MANGLE_LREST
:
18854 SET_NAME (rule
, rule_buf
[rule_pos
]);
18857 case RULE_OP_MANGLE_UREST
:
18858 SET_NAME (rule
, rule_buf
[rule_pos
]);
18861 case RULE_OP_MANGLE_LREST_UFIRST
:
18862 SET_NAME (rule
, rule_buf
[rule_pos
]);
18865 case RULE_OP_MANGLE_UREST_LFIRST
:
18866 SET_NAME (rule
, rule_buf
[rule_pos
]);
18869 case RULE_OP_MANGLE_TREST
:
18870 SET_NAME (rule
, rule_buf
[rule_pos
]);
18873 case RULE_OP_MANGLE_TOGGLE_AT
:
18874 SET_NAME (rule
, rule_buf
[rule_pos
]);
18875 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18878 case RULE_OP_MANGLE_REVERSE
:
18879 SET_NAME (rule
, rule_buf
[rule_pos
]);
18882 case RULE_OP_MANGLE_DUPEWORD
:
18883 SET_NAME (rule
, rule_buf
[rule_pos
]);
18886 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18887 SET_NAME (rule
, rule_buf
[rule_pos
]);
18888 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18891 case RULE_OP_MANGLE_REFLECT
:
18892 SET_NAME (rule
, rule_buf
[rule_pos
]);
18895 case RULE_OP_MANGLE_ROTATE_LEFT
:
18896 SET_NAME (rule
, rule_buf
[rule_pos
]);
18899 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18900 SET_NAME (rule
, rule_buf
[rule_pos
]);
18903 case RULE_OP_MANGLE_APPEND
:
18904 SET_NAME (rule
, rule_buf
[rule_pos
]);
18905 SET_P0 (rule
, rule_buf
[rule_pos
]);
18908 case RULE_OP_MANGLE_PREPEND
:
18909 SET_NAME (rule
, rule_buf
[rule_pos
]);
18910 SET_P0 (rule
, rule_buf
[rule_pos
]);
18913 case RULE_OP_MANGLE_DELETE_FIRST
:
18914 SET_NAME (rule
, rule_buf
[rule_pos
]);
18917 case RULE_OP_MANGLE_DELETE_LAST
:
18918 SET_NAME (rule
, rule_buf
[rule_pos
]);
18921 case RULE_OP_MANGLE_DELETE_AT
:
18922 SET_NAME (rule
, rule_buf
[rule_pos
]);
18923 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18926 case RULE_OP_MANGLE_EXTRACT
:
18927 SET_NAME (rule
, rule_buf
[rule_pos
]);
18928 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18929 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18932 case RULE_OP_MANGLE_OMIT
:
18933 SET_NAME (rule
, rule_buf
[rule_pos
]);
18934 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18935 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18938 case RULE_OP_MANGLE_INSERT
:
18939 SET_NAME (rule
, rule_buf
[rule_pos
]);
18940 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18941 SET_P1 (rule
, rule_buf
[rule_pos
]);
18944 case RULE_OP_MANGLE_OVERSTRIKE
:
18945 SET_NAME (rule
, rule_buf
[rule_pos
]);
18946 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18947 SET_P1 (rule
, rule_buf
[rule_pos
]);
18950 case RULE_OP_MANGLE_TRUNCATE_AT
:
18951 SET_NAME (rule
, rule_buf
[rule_pos
]);
18952 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18955 case RULE_OP_MANGLE_REPLACE
:
18956 SET_NAME (rule
, rule_buf
[rule_pos
]);
18957 SET_P0 (rule
, rule_buf
[rule_pos
]);
18958 SET_P1 (rule
, rule_buf
[rule_pos
]);
18961 case RULE_OP_MANGLE_PURGECHAR
:
18965 case RULE_OP_MANGLE_TOGGLECASE_REC
:
18969 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
18970 SET_NAME (rule
, rule_buf
[rule_pos
]);
18971 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18974 case RULE_OP_MANGLE_DUPECHAR_LAST
:
18975 SET_NAME (rule
, rule_buf
[rule_pos
]);
18976 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18979 case RULE_OP_MANGLE_DUPECHAR_ALL
:
18980 SET_NAME (rule
, rule_buf
[rule_pos
]);
18983 case RULE_OP_MANGLE_SWITCH_FIRST
:
18984 SET_NAME (rule
, rule_buf
[rule_pos
]);
18987 case RULE_OP_MANGLE_SWITCH_LAST
:
18988 SET_NAME (rule
, rule_buf
[rule_pos
]);
18991 case RULE_OP_MANGLE_SWITCH_AT
:
18992 SET_NAME (rule
, rule_buf
[rule_pos
]);
18993 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18994 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18997 case RULE_OP_MANGLE_CHR_SHIFTL
:
18998 SET_NAME (rule
, rule_buf
[rule_pos
]);
18999 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19002 case RULE_OP_MANGLE_CHR_SHIFTR
:
19003 SET_NAME (rule
, rule_buf
[rule_pos
]);
19004 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19007 case RULE_OP_MANGLE_CHR_INCR
:
19008 SET_NAME (rule
, rule_buf
[rule_pos
]);
19009 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19012 case RULE_OP_MANGLE_CHR_DECR
:
19013 SET_NAME (rule
, rule_buf
[rule_pos
]);
19014 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19017 case RULE_OP_MANGLE_REPLACE_NP1
:
19018 SET_NAME (rule
, rule_buf
[rule_pos
]);
19019 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19022 case RULE_OP_MANGLE_REPLACE_NM1
:
19023 SET_NAME (rule
, rule_buf
[rule_pos
]);
19024 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19027 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19028 SET_NAME (rule
, rule_buf
[rule_pos
]);
19029 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19032 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19033 SET_NAME (rule
, rule_buf
[rule_pos
]);
19034 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19037 case RULE_OP_MANGLE_TITLE
:
19038 SET_NAME (rule
, rule_buf
[rule_pos
]);
19047 if (rule_pos
< rule_len
) return (-1);
19052 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19056 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19060 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19064 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19068 case RULE_OP_MANGLE_NOOP
:
19069 rule_buf
[rule_pos
] = rule_cmd
;
19072 case RULE_OP_MANGLE_LREST
:
19073 rule_buf
[rule_pos
] = rule_cmd
;
19076 case RULE_OP_MANGLE_UREST
:
19077 rule_buf
[rule_pos
] = rule_cmd
;
19080 case RULE_OP_MANGLE_LREST_UFIRST
:
19081 rule_buf
[rule_pos
] = rule_cmd
;
19084 case RULE_OP_MANGLE_UREST_LFIRST
:
19085 rule_buf
[rule_pos
] = rule_cmd
;
19088 case RULE_OP_MANGLE_TREST
:
19089 rule_buf
[rule_pos
] = rule_cmd
;
19092 case RULE_OP_MANGLE_TOGGLE_AT
:
19093 rule_buf
[rule_pos
] = rule_cmd
;
19094 GET_P0_CONV (rule
);
19097 case RULE_OP_MANGLE_REVERSE
:
19098 rule_buf
[rule_pos
] = rule_cmd
;
19101 case RULE_OP_MANGLE_DUPEWORD
:
19102 rule_buf
[rule_pos
] = rule_cmd
;
19105 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19106 rule_buf
[rule_pos
] = rule_cmd
;
19107 GET_P0_CONV (rule
);
19110 case RULE_OP_MANGLE_REFLECT
:
19111 rule_buf
[rule_pos
] = rule_cmd
;
19114 case RULE_OP_MANGLE_ROTATE_LEFT
:
19115 rule_buf
[rule_pos
] = rule_cmd
;
19118 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19119 rule_buf
[rule_pos
] = rule_cmd
;
19122 case RULE_OP_MANGLE_APPEND
:
19123 rule_buf
[rule_pos
] = rule_cmd
;
19127 case RULE_OP_MANGLE_PREPEND
:
19128 rule_buf
[rule_pos
] = rule_cmd
;
19132 case RULE_OP_MANGLE_DELETE_FIRST
:
19133 rule_buf
[rule_pos
] = rule_cmd
;
19136 case RULE_OP_MANGLE_DELETE_LAST
:
19137 rule_buf
[rule_pos
] = rule_cmd
;
19140 case RULE_OP_MANGLE_DELETE_AT
:
19141 rule_buf
[rule_pos
] = rule_cmd
;
19142 GET_P0_CONV (rule
);
19145 case RULE_OP_MANGLE_EXTRACT
:
19146 rule_buf
[rule_pos
] = rule_cmd
;
19147 GET_P0_CONV (rule
);
19148 GET_P1_CONV (rule
);
19151 case RULE_OP_MANGLE_OMIT
:
19152 rule_buf
[rule_pos
] = rule_cmd
;
19153 GET_P0_CONV (rule
);
19154 GET_P1_CONV (rule
);
19157 case RULE_OP_MANGLE_INSERT
:
19158 rule_buf
[rule_pos
] = rule_cmd
;
19159 GET_P0_CONV (rule
);
19163 case RULE_OP_MANGLE_OVERSTRIKE
:
19164 rule_buf
[rule_pos
] = rule_cmd
;
19165 GET_P0_CONV (rule
);
19169 case RULE_OP_MANGLE_TRUNCATE_AT
:
19170 rule_buf
[rule_pos
] = rule_cmd
;
19171 GET_P0_CONV (rule
);
19174 case RULE_OP_MANGLE_REPLACE
:
19175 rule_buf
[rule_pos
] = rule_cmd
;
19180 case RULE_OP_MANGLE_PURGECHAR
:
19184 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19188 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19189 rule_buf
[rule_pos
] = rule_cmd
;
19190 GET_P0_CONV (rule
);
19193 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19194 rule_buf
[rule_pos
] = rule_cmd
;
19195 GET_P0_CONV (rule
);
19198 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19199 rule_buf
[rule_pos
] = rule_cmd
;
19202 case RULE_OP_MANGLE_SWITCH_FIRST
:
19203 rule_buf
[rule_pos
] = rule_cmd
;
19206 case RULE_OP_MANGLE_SWITCH_LAST
:
19207 rule_buf
[rule_pos
] = rule_cmd
;
19210 case RULE_OP_MANGLE_SWITCH_AT
:
19211 rule_buf
[rule_pos
] = rule_cmd
;
19212 GET_P0_CONV (rule
);
19213 GET_P1_CONV (rule
);
19216 case RULE_OP_MANGLE_CHR_SHIFTL
:
19217 rule_buf
[rule_pos
] = rule_cmd
;
19218 GET_P0_CONV (rule
);
19221 case RULE_OP_MANGLE_CHR_SHIFTR
:
19222 rule_buf
[rule_pos
] = rule_cmd
;
19223 GET_P0_CONV (rule
);
19226 case RULE_OP_MANGLE_CHR_INCR
:
19227 rule_buf
[rule_pos
] = rule_cmd
;
19228 GET_P0_CONV (rule
);
19231 case RULE_OP_MANGLE_CHR_DECR
:
19232 rule_buf
[rule_pos
] = rule_cmd
;
19233 GET_P0_CONV (rule
);
19236 case RULE_OP_MANGLE_REPLACE_NP1
:
19237 rule_buf
[rule_pos
] = rule_cmd
;
19238 GET_P0_CONV (rule
);
19241 case RULE_OP_MANGLE_REPLACE_NM1
:
19242 rule_buf
[rule_pos
] = rule_cmd
;
19243 GET_P0_CONV (rule
);
19246 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19247 rule_buf
[rule_pos
] = rule_cmd
;
19248 GET_P0_CONV (rule
);
19251 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19252 rule_buf
[rule_pos
] = rule_cmd
;
19253 GET_P0_CONV (rule
);
19256 case RULE_OP_MANGLE_TITLE
:
19257 rule_buf
[rule_pos
] = rule_cmd
;
19261 return rule_pos
- 1;
19279 * CPU rules : this is from hashcat sources, cpu based rules
19282 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19283 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19285 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19286 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19287 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19289 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19290 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19291 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19293 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19297 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19302 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19306 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19311 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19315 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19320 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19325 for (l
= 0; l
< arr_len
; l
++)
19327 r
= arr_len
- 1 - l
;
19331 MANGLE_SWITCH (arr
, l
, r
);
19337 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19339 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19341 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19343 return (arr_len
* 2);
19346 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19348 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19350 int orig_len
= arr_len
;
19354 for (i
= 0; i
< times
; i
++)
19356 memcpy (&arr
[arr_len
], arr
, orig_len
);
19358 arr_len
+= orig_len
;
19364 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19366 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19368 mangle_double (arr
, arr_len
);
19370 mangle_reverse (arr
+ arr_len
, arr_len
);
19372 return (arr_len
* 2);
19375 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19380 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19382 MANGLE_SWITCH (arr
, l
, r
);
19388 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19393 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19395 MANGLE_SWITCH (arr
, l
, r
);
19401 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19403 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19407 return (arr_len
+ 1);
19410 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19412 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19416 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19418 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19423 return (arr_len
+ 1);
19426 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19428 if (upos
>= arr_len
) return (arr_len
);
19432 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19434 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19437 return (arr_len
- 1);
19440 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19442 if (upos
>= arr_len
) return (arr_len
);
19444 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19448 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19450 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19456 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19458 if (upos
>= arr_len
) return (arr_len
);
19460 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19464 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19466 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19469 return (arr_len
- ulen
);
19472 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19474 if (upos
>= arr_len
) return (arr_len
);
19476 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19480 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19482 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19487 return (arr_len
+ 1);
19490 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
)
19492 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19494 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19496 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19498 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19500 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19502 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19504 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19506 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19508 return (arr_len
+ arr2_cpy
);
19511 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19513 if (upos
>= arr_len
) return (arr_len
);
19520 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19522 if (upos
>= arr_len
) return (arr_len
);
19524 memset (arr
+ upos
, 0, arr_len
- upos
);
19529 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19533 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19535 if (arr
[arr_pos
] != oldc
) continue;
19537 arr
[arr_pos
] = newc
;
19543 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19549 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19551 if (arr
[arr_pos
] == c
) continue;
19553 arr
[ret_len
] = arr
[arr_pos
];
19561 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19563 if (ulen
> arr_len
) return (arr_len
);
19565 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19569 memcpy (cs
, arr
, ulen
);
19573 for (i
= 0; i
< ulen
; i
++)
19577 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19583 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19585 if (ulen
> arr_len
) return (arr_len
);
19587 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19589 int upos
= arr_len
- ulen
;
19593 for (i
= 0; i
< ulen
; i
++)
19595 char c
= arr
[upos
+ i
];
19597 arr_len
= mangle_append (arr
, arr_len
, c
);
19603 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19605 if ( arr_len
== 0) return (arr_len
);
19606 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19608 char c
= arr
[upos
];
19612 for (i
= 0; i
< ulen
; i
++)
19614 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19620 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19622 if ( arr_len
== 0) return (arr_len
);
19623 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19627 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19629 int new_pos
= arr_pos
* 2;
19631 arr
[new_pos
] = arr
[arr_pos
];
19633 arr
[new_pos
+ 1] = arr
[arr_pos
];
19636 return (arr_len
* 2);
19639 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19641 if (upos
>= arr_len
) return (arr_len
);
19642 if (upos2
>= arr_len
) return (arr_len
);
19644 MANGLE_SWITCH (arr
, upos
, upos2
);
19649 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19651 MANGLE_SWITCH (arr
, upos
, upos2
);
19656 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19658 if (upos
>= arr_len
) return (arr_len
);
19665 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19667 if (upos
>= arr_len
) return (arr_len
);
19674 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19676 if (upos
>= arr_len
) return (arr_len
);
19683 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19685 if (upos
>= arr_len
) return (arr_len
);
19692 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19694 int upper_next
= 1;
19698 for (pos
= 0; pos
< arr_len
; pos
++)
19700 if (arr
[pos
] == ' ')
19711 MANGLE_UPPER_AT (arr
, pos
);
19715 MANGLE_LOWER_AT (arr
, pos
);
19722 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19724 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19728 uint32_t rule_pos
= 0;
19730 for (j
= 0; j
< rp_gen_num
; j
++)
19737 switch ((char) get_random_num (0, 9))
19740 r
= get_random_num (0, sizeof (grp_op_nop
));
19741 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19745 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19746 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19747 p1
= get_random_num (0, sizeof (grp_pos
));
19748 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19752 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19753 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19754 p1
= get_random_num (1, 6);
19755 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19759 r
= get_random_num (0, sizeof (grp_op_chr
));
19760 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19761 p1
= get_random_num (0x20, 0x7e);
19762 rule_buf
[rule_pos
++] = (char) p1
;
19766 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19767 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19768 p1
= get_random_num (0x20, 0x7e);
19769 rule_buf
[rule_pos
++] = (char) p1
;
19770 p2
= get_random_num (0x20, 0x7e);
19772 p2
= get_random_num (0x20, 0x7e);
19773 rule_buf
[rule_pos
++] = (char) p2
;
19777 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19778 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19779 p1
= get_random_num (0, sizeof (grp_pos
));
19780 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19781 p2
= get_random_num (0x20, 0x7e);
19782 rule_buf
[rule_pos
++] = (char) p2
;
19786 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19787 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19788 p1
= get_random_num (0, sizeof (grp_pos
));
19789 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19790 p2
= get_random_num (0, sizeof (grp_pos
));
19792 p2
= get_random_num (0, sizeof (grp_pos
));
19793 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19797 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19798 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19799 p1
= get_random_num (0, sizeof (grp_pos
));
19800 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19801 p2
= get_random_num (1, sizeof (grp_pos
));
19803 p2
= get_random_num (1, sizeof (grp_pos
));
19804 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19808 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19809 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19810 p1
= get_random_num (0, sizeof (grp_pos
));
19811 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19812 p2
= get_random_num (1, sizeof (grp_pos
));
19813 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19814 p3
= get_random_num (0, sizeof (grp_pos
));
19815 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19823 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19825 char mem
[BLOCK_SIZE
];
19827 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19829 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19831 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19833 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19835 int out_len
= in_len
;
19836 int mem_len
= in_len
;
19838 memcpy (out
, in
, out_len
);
19842 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19844 int upos
; int upos2
;
19847 switch (rule
[rule_pos
])
19852 case RULE_OP_MANGLE_NOOP
:
19855 case RULE_OP_MANGLE_LREST
:
19856 out_len
= mangle_lrest (out
, out_len
);
19859 case RULE_OP_MANGLE_UREST
:
19860 out_len
= mangle_urest (out
, out_len
);
19863 case RULE_OP_MANGLE_LREST_UFIRST
:
19864 out_len
= mangle_lrest (out
, out_len
);
19865 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19868 case RULE_OP_MANGLE_UREST_LFIRST
:
19869 out_len
= mangle_urest (out
, out_len
);
19870 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19873 case RULE_OP_MANGLE_TREST
:
19874 out_len
= mangle_trest (out
, out_len
);
19877 case RULE_OP_MANGLE_TOGGLE_AT
:
19878 NEXT_RULEPOS (rule_pos
);
19879 NEXT_RPTOI (rule
, rule_pos
, upos
);
19880 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19883 case RULE_OP_MANGLE_REVERSE
:
19884 out_len
= mangle_reverse (out
, out_len
);
19887 case RULE_OP_MANGLE_DUPEWORD
:
19888 out_len
= mangle_double (out
, out_len
);
19891 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19892 NEXT_RULEPOS (rule_pos
);
19893 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19894 out_len
= mangle_double_times (out
, out_len
, ulen
);
19897 case RULE_OP_MANGLE_REFLECT
:
19898 out_len
= mangle_reflect (out
, out_len
);
19901 case RULE_OP_MANGLE_ROTATE_LEFT
:
19902 mangle_rotate_left (out
, out_len
);
19905 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19906 mangle_rotate_right (out
, out_len
);
19909 case RULE_OP_MANGLE_APPEND
:
19910 NEXT_RULEPOS (rule_pos
);
19911 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19914 case RULE_OP_MANGLE_PREPEND
:
19915 NEXT_RULEPOS (rule_pos
);
19916 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19919 case RULE_OP_MANGLE_DELETE_FIRST
:
19920 out_len
= mangle_delete_at (out
, out_len
, 0);
19923 case RULE_OP_MANGLE_DELETE_LAST
:
19924 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19927 case RULE_OP_MANGLE_DELETE_AT
:
19928 NEXT_RULEPOS (rule_pos
);
19929 NEXT_RPTOI (rule
, rule_pos
, upos
);
19930 out_len
= mangle_delete_at (out
, out_len
, upos
);
19933 case RULE_OP_MANGLE_EXTRACT
:
19934 NEXT_RULEPOS (rule_pos
);
19935 NEXT_RPTOI (rule
, rule_pos
, upos
);
19936 NEXT_RULEPOS (rule_pos
);
19937 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19938 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19941 case RULE_OP_MANGLE_OMIT
:
19942 NEXT_RULEPOS (rule_pos
);
19943 NEXT_RPTOI (rule
, rule_pos
, upos
);
19944 NEXT_RULEPOS (rule_pos
);
19945 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19946 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19949 case RULE_OP_MANGLE_INSERT
:
19950 NEXT_RULEPOS (rule_pos
);
19951 NEXT_RPTOI (rule
, rule_pos
, upos
);
19952 NEXT_RULEPOS (rule_pos
);
19953 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19956 case RULE_OP_MANGLE_OVERSTRIKE
:
19957 NEXT_RULEPOS (rule_pos
);
19958 NEXT_RPTOI (rule
, rule_pos
, upos
);
19959 NEXT_RULEPOS (rule_pos
);
19960 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
19963 case RULE_OP_MANGLE_TRUNCATE_AT
:
19964 NEXT_RULEPOS (rule_pos
);
19965 NEXT_RPTOI (rule
, rule_pos
, upos
);
19966 out_len
= mangle_truncate_at (out
, out_len
, upos
);
19969 case RULE_OP_MANGLE_REPLACE
:
19970 NEXT_RULEPOS (rule_pos
);
19971 NEXT_RULEPOS (rule_pos
);
19972 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
19975 case RULE_OP_MANGLE_PURGECHAR
:
19976 NEXT_RULEPOS (rule_pos
);
19977 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
19980 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19984 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19985 NEXT_RULEPOS (rule_pos
);
19986 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19987 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
19990 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19991 NEXT_RULEPOS (rule_pos
);
19992 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19993 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
19996 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19997 out_len
= mangle_dupechar (out
, out_len
);
20000 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20001 NEXT_RULEPOS (rule_pos
);
20002 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20003 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20006 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20007 NEXT_RULEPOS (rule_pos
);
20008 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20009 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20012 case RULE_OP_MANGLE_SWITCH_FIRST
:
20013 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20016 case RULE_OP_MANGLE_SWITCH_LAST
:
20017 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20020 case RULE_OP_MANGLE_SWITCH_AT
:
20021 NEXT_RULEPOS (rule_pos
);
20022 NEXT_RPTOI (rule
, rule_pos
, upos
);
20023 NEXT_RULEPOS (rule_pos
);
20024 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20025 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20028 case RULE_OP_MANGLE_CHR_SHIFTL
:
20029 NEXT_RULEPOS (rule_pos
);
20030 NEXT_RPTOI (rule
, rule_pos
, upos
);
20031 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20034 case RULE_OP_MANGLE_CHR_SHIFTR
:
20035 NEXT_RULEPOS (rule_pos
);
20036 NEXT_RPTOI (rule
, rule_pos
, upos
);
20037 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20040 case RULE_OP_MANGLE_CHR_INCR
:
20041 NEXT_RULEPOS (rule_pos
);
20042 NEXT_RPTOI (rule
, rule_pos
, upos
);
20043 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20046 case RULE_OP_MANGLE_CHR_DECR
:
20047 NEXT_RULEPOS (rule_pos
);
20048 NEXT_RPTOI (rule
, rule_pos
, upos
);
20049 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20052 case RULE_OP_MANGLE_REPLACE_NP1
:
20053 NEXT_RULEPOS (rule_pos
);
20054 NEXT_RPTOI (rule
, rule_pos
, upos
);
20055 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20058 case RULE_OP_MANGLE_REPLACE_NM1
:
20059 NEXT_RULEPOS (rule_pos
);
20060 NEXT_RPTOI (rule
, rule_pos
, upos
);
20061 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20064 case RULE_OP_MANGLE_TITLE
:
20065 out_len
= mangle_title (out
, out_len
);
20068 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20069 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20070 NEXT_RULEPOS (rule_pos
);
20071 NEXT_RPTOI (rule
, rule_pos
, upos
);
20072 NEXT_RULEPOS (rule_pos
);
20073 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20074 NEXT_RULEPOS (rule_pos
);
20075 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20076 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20079 case RULE_OP_MANGLE_APPEND_MEMORY
:
20080 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20081 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20082 memcpy (out
+ out_len
, mem
, mem_len
);
20083 out_len
+= mem_len
;
20086 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20087 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20088 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20089 memcpy (mem
+ mem_len
, out
, out_len
);
20090 out_len
+= mem_len
;
20091 memcpy (out
, mem
, out_len
);
20094 case RULE_OP_MEMORIZE_WORD
:
20095 memcpy (mem
, out
, out_len
);
20099 case RULE_OP_REJECT_LESS
:
20100 NEXT_RULEPOS (rule_pos
);
20101 NEXT_RPTOI (rule
, rule_pos
, upos
);
20102 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20105 case RULE_OP_REJECT_GREATER
:
20106 NEXT_RULEPOS (rule_pos
);
20107 NEXT_RPTOI (rule
, rule_pos
, upos
);
20108 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20111 case RULE_OP_REJECT_CONTAIN
:
20112 NEXT_RULEPOS (rule_pos
);
20113 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20116 case RULE_OP_REJECT_NOT_CONTAIN
:
20117 NEXT_RULEPOS (rule_pos
);
20118 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20121 case RULE_OP_REJECT_EQUAL_FIRST
:
20122 NEXT_RULEPOS (rule_pos
);
20123 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20126 case RULE_OP_REJECT_EQUAL_LAST
:
20127 NEXT_RULEPOS (rule_pos
);
20128 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20131 case RULE_OP_REJECT_EQUAL_AT
:
20132 NEXT_RULEPOS (rule_pos
);
20133 NEXT_RPTOI (rule
, rule_pos
, upos
);
20134 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20135 NEXT_RULEPOS (rule_pos
);
20136 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20139 case RULE_OP_REJECT_CONTAINS
:
20140 NEXT_RULEPOS (rule_pos
);
20141 NEXT_RPTOI (rule
, rule_pos
, upos
);
20142 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20143 NEXT_RULEPOS (rule_pos
);
20144 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20145 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20148 case RULE_OP_REJECT_MEMORY
:
20149 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20153 return (RULE_RC_SYNTAX_ERROR
);
20158 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);