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) KERNEL_ACCEL_ ## x
17 #define GET_LOOPS(x) KERNEL_LOOPS_ ## 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
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.vendor_id
== VENDOR_ID_AMD
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3090 if (data
.vendor_id
== VENDOR_ID_NV
)
3093 int temperature
= 0;
3095 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3101 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3103 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3104 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3105 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3106 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3108 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3110 return pThermalSettings
.sensor
[0].currentTemp
;
3117 int hm_get_fanspeed_with_device_id (const uint device_id
)
3119 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3120 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3122 if (data
.hm_device
[device_id
].fan_supported
== 1)
3124 if (data
.vendor_id
== VENDOR_ID_AMD
)
3128 if (data
.hm_device
[device_id
].od_version
== 5)
3130 ADLFanSpeedValue lpFanSpeedValue
;
3132 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3134 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3135 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3136 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3138 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3140 return lpFanSpeedValue
.iFanSpeed
;
3142 else // od_version == 6
3144 ADLOD6FanSpeedInfo faninfo
;
3146 memset (&faninfo
, 0, sizeof (faninfo
));
3148 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3150 return faninfo
.iFanSpeedPercent
;
3155 if (data
.vendor_id
== VENDOR_ID_NV
)
3160 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3168 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3178 int hm_get_utilization_with_device_id (const uint device_id
)
3180 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3182 if (data
.vendor_id
== VENDOR_ID_AMD
)
3186 ADLPMActivity PMActivity
;
3188 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3190 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3192 return PMActivity
.iActivityPercent
;
3196 if (data
.vendor_id
== VENDOR_ID_NV
)
3199 nvmlUtilization_t utilization
;
3201 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3203 return utilization
.gpu
;
3207 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3209 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3211 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3213 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3220 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3222 if (data
.hm_device
[device_id
].fan_supported
== 1)
3226 if (data
.hm_device
[device_id
].od_version
== 5)
3228 ADLFanSpeedValue lpFanSpeedValue
;
3230 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3232 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3233 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3234 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3235 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3237 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3241 else // od_version == 6
3243 ADLOD6FanSpeedValue fan_speed_value
;
3245 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3247 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3248 fan_speed_value
.iFanSpeed
= fanspeed
;
3250 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3260 // helper function for status display
3262 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3264 #define VALUE_NOT_AVAILABLE "N/A"
3268 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3272 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3280 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3282 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3284 if (css_cnt
> SP_PW_MAX
)
3286 log_error ("ERROR: mask length is too long");
3291 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3293 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3295 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3296 uint cs_len
= css
[css_pos
].cs_len
;
3298 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3300 uint c
= cs_buf
[cs_pos
] & 0xff;
3307 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3309 cs_t
*cs
= &css
[css_cnt
];
3311 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3313 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3315 memset (css_uniq
, 0, css_uniq_sz
);
3319 for (i
= 0; i
< cs
->cs_len
; i
++)
3321 const uint u
= cs
->cs_buf
[i
];
3326 for (i
= 0; i
< in_len
; i
++)
3328 uint u
= in_buf
[i
] & 0xff;
3330 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3332 if (css_uniq
[u
] == 1) continue;
3336 cs
->cs_buf
[cs
->cs_len
] = u
;
3344 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3348 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3350 uint p0
= in_buf
[in_pos
] & 0xff;
3352 if (interpret
== 1 && p0
== '?')
3356 if (in_pos
== in_len
) break;
3358 uint p1
= in_buf
[in_pos
] & 0xff;
3362 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3364 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3366 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3368 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3370 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3372 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3374 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3375 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3377 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3378 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3381 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3383 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3384 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3386 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3388 default: log_error ("Syntax error: %s", in_buf
);
3394 if (data
.hex_charset
)
3398 if (in_pos
== in_len
)
3400 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3405 uint p1
= in_buf
[in_pos
] & 0xff;
3407 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3409 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3416 chr
= hex_convert (p1
) << 0;
3417 chr
|= hex_convert (p0
) << 4;
3419 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3425 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3431 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3435 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3437 sum
*= css
[css_pos
].cs_len
;
3443 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3445 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3450 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3452 char p0
= mask_buf
[mask_pos
];
3458 if (mask_pos
== mask_len
) break;
3460 char p1
= mask_buf
[mask_pos
];
3466 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3468 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3470 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3472 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3474 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3476 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3478 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3479 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3481 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3482 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3484 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3485 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3487 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3488 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3490 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3492 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3498 if (data
.hex_charset
)
3502 // if there is no 2nd hex character, show an error:
3504 if (mask_pos
== mask_len
)
3506 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3511 char p1
= mask_buf
[mask_pos
];
3513 // if they are not valid hex character, show an error:
3515 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3517 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3524 chr
|= hex_convert (p1
) << 0;
3525 chr
|= hex_convert (p0
) << 4;
3527 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3533 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3540 log_error ("ERROR: invalid mask length (0)");
3550 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3552 for (int i
= 0; i
< css_cnt
; i
++)
3554 uint len
= css
[i
].cs_len
;
3555 uint64_t next
= val
/ len
;
3556 uint pos
= val
% len
;
3557 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3562 void mp_cut_at (char *mask
, uint max
)
3566 uint mask_len
= strlen (mask
);
3568 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3570 if (mask
[i
] == '?') i
++;
3576 void mp_setup_sys (cs_t
*mp_sys
)
3580 uint donec
[CHARSIZ
];
3582 memset (donec
, 0, sizeof (donec
));
3584 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3585 mp_sys
[0].cs_buf
[pos
++] = chr
;
3586 mp_sys
[0].cs_len
= pos
; }
3588 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3589 mp_sys
[1].cs_buf
[pos
++] = chr
;
3590 mp_sys
[1].cs_len
= pos
; }
3592 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3593 mp_sys
[2].cs_buf
[pos
++] = chr
;
3594 mp_sys
[2].cs_len
= pos
; }
3596 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3597 mp_sys
[3].cs_buf
[pos
++] = chr
;
3598 mp_sys
[3].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3601 mp_sys
[4].cs_len
= pos
; }
3603 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3604 mp_sys
[5].cs_len
= pos
; }
3607 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3609 FILE *fp
= fopen (buf
, "rb");
3611 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3613 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3619 memset (mp_file
, 0, sizeof (mp_file
));
3621 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3625 len
= in_superchop (mp_file
);
3629 log_info ("WARNING: charset file corrupted");
3631 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3635 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3640 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3642 mp_usr
[index
].cs_len
= 0;
3644 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3647 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3649 char *new_mask_buf
= (char *) mymalloc (256);
3655 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3657 if (css_pos
== len
) break;
3659 char p0
= mask_buf
[mask_pos
];
3661 new_mask_buf
[mask_pos
] = p0
;
3667 if (mask_pos
== mask_len
) break;
3669 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3673 if (data
.hex_charset
)
3677 if (mask_pos
== mask_len
)
3679 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3684 char p1
= mask_buf
[mask_pos
];
3686 // if they are not valid hex character, show an error:
3688 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3690 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3695 new_mask_buf
[mask_pos
] = p1
;
3700 if (css_pos
== len
) return (new_mask_buf
);
3702 myfree (new_mask_buf
);
3711 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3717 for (i
= start
; i
< stop
; i
++)
3719 sum
*= root_css_buf
[i
].cs_len
;
3725 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3729 cs_t
*cs
= &root_css_buf
[start
];
3733 for (i
= start
; i
< stop
; i
++)
3735 const uint64_t m
= v
% cs
->cs_len
;
3736 const uint64_t d
= v
/ cs
->cs_len
;
3740 const uint k
= cs
->cs_buf
[m
];
3742 pw_buf
[i
- start
] = (char) k
;
3744 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3748 int sp_comp_val (const void *p1
, const void *p2
)
3750 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3751 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3753 return b2
->val
- b1
->val
;
3756 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3763 * Initialize hcstats
3766 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3768 uint64_t *root_stats_ptr
= root_stats_buf
;
3770 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3772 for (i
= 0; i
< SP_PW_MAX
; i
++)
3774 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3776 root_stats_ptr
+= CHARSIZ
;
3779 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3781 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3783 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3785 for (i
= 0; i
< SP_PW_MAX
; i
++)
3787 for (j
= 0; j
< CHARSIZ
; j
++)
3789 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3791 markov_stats_ptr
+= CHARSIZ
;
3801 char hcstat_tmp
[256];
3803 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3805 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3807 hcstat
= hcstat_tmp
;
3810 FILE *fd
= fopen (hcstat
, "rb");
3814 log_error ("%s: %s", hcstat
, strerror (errno
));
3819 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3821 log_error ("%s: Could not load data", hcstat
);
3826 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3828 log_error ("%s: Could not load data", hcstat
);
3836 * Markov modifier of hcstat_table on user request
3841 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3842 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3847 /* Add all stats to first position */
3849 for (i
= 1; i
< SP_PW_MAX
; i
++)
3851 uint64_t *out
= root_stats_buf_by_pos
[0];
3852 uint64_t *in
= root_stats_buf_by_pos
[i
];
3854 for (j
= 0; j
< CHARSIZ
; j
++)
3860 for (i
= 1; i
< SP_PW_MAX
; i
++)
3862 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3863 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3865 for (j
= 0; j
< CHARSIZ
; j
++)
3867 for (k
= 0; k
< CHARSIZ
; k
++)
3874 /* copy them to all pw_positions */
3876 for (i
= 1; i
< SP_PW_MAX
; i
++)
3878 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3881 for (i
= 1; i
< SP_PW_MAX
; i
++)
3883 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3891 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3893 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3895 for (i
= 0; i
< SP_PW_MAX
; i
++)
3897 root_table_buf_by_pos
[i
] = root_table_ptr
;
3899 root_table_ptr
+= CHARSIZ
;
3902 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3904 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3906 for (i
= 0; i
< SP_PW_MAX
; i
++)
3908 for (j
= 0; j
< CHARSIZ
; j
++)
3910 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3912 markov_table_ptr
+= CHARSIZ
;
3917 * Convert hcstat to tables
3920 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3922 uint key
= i
% CHARSIZ
;
3924 root_table_buf
[i
].key
= key
;
3925 root_table_buf
[i
].val
= root_stats_buf
[i
];
3928 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3930 uint key
= i
% CHARSIZ
;
3932 markov_table_buf
[i
].key
= key
;
3933 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3936 myfree (root_stats_buf
);
3937 myfree (markov_stats_buf
);
3943 for (i
= 0; i
< SP_PW_MAX
; i
++)
3945 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3948 for (i
= 0; i
< SP_PW_MAX
; i
++)
3950 for (j
= 0; j
< CHARSIZ
; j
++)
3952 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3957 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
])
3960 * Convert tables to css
3963 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3965 uint pw_pos
= i
/ CHARSIZ
;
3967 cs_t
*cs
= &root_css_buf
[pw_pos
];
3969 if (cs
->cs_len
== threshold
) continue;
3971 uint key
= root_table_buf
[i
].key
;
3973 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3975 cs
->cs_buf
[cs
->cs_len
] = key
;
3981 * Convert table to css
3984 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3986 uint c
= i
/ CHARSIZ
;
3988 cs_t
*cs
= &markov_css_buf
[c
];
3990 if (cs
->cs_len
== threshold
) continue;
3992 uint pw_pos
= c
/ CHARSIZ
;
3994 uint key
= markov_table_buf
[i
].key
;
3996 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3998 cs
->cs_buf
[cs
->cs_len
] = key
;
4004 for (uint i = 0; i < 8; i++)
4006 for (uint j = 0x20; j < 0x80; j++)
4008 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4010 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4012 for (uint k = 0; k < 10; k++)
4014 printf (" %u\n", ptr->cs_buf[k]);
4021 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4023 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4025 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4035 for (uint j
= 1; j
< CHARSIZ
; j
++)
4045 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4047 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4049 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4051 out
+= CHARSIZ
* CHARSIZ
;
4052 in
+= CHARSIZ
* CHARSIZ
;
4054 for (uint j
= 0; j
< CHARSIZ
; j
++)
4061 for (uint k
= 1; k
< CHARSIZ
; k
++)
4073 * mixed shared functions
4076 void dump_hex (const char *s
, size_t size
)
4080 for (i
= 0; i
< size
; i
++)
4082 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4088 void usage_mini_print (const char *progname
)
4090 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4093 void usage_big_print (const char *progname
)
4095 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4098 char *get_exec_path ()
4100 int exec_path_len
= 1024;
4102 char *exec_path
= (char *) mymalloc (exec_path_len
);
4108 sprintf (tmp
, "/proc/%d/exe", getpid ());
4110 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4116 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4125 char *get_install_dir (const char *progname
)
4127 char *install_dir
= mystrdup (progname
);
4128 char *last_slash
= NULL
;
4130 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4134 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4140 install_dir
[0] = '.';
4144 return (install_dir
);
4147 char *get_profile_dir (const char *homedir
)
4149 #define DOT_HASHCAT ".hashcat"
4151 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4153 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4158 char *get_session_dir (const char *profile_dir
)
4160 #define SESSIONS_FOLDER "sessions"
4162 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4164 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4169 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4173 FILE *fd
= fopen (file
, "rb");
4177 log_error ("%s: %s", file
, strerror (errno
));
4182 #define MAX_KEY_SIZE (1024 * 1024)
4184 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4186 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4190 for (int fpos
= 0; fpos
< nread
; fpos
++)
4192 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4194 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4195 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4196 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4197 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4199 if (kpos
>= 64) kpos
= 0;
4207 void set_cpu_affinity (char *cpu_affinity
)
4210 DWORD_PTR aff_mask
= 0;
4221 char *devices
= strdup (cpu_affinity
);
4223 char *next
= strtok (devices
, ",");
4227 uint cpu_id
= atoi (next
);
4244 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4250 aff_mask
|= 1 << (cpu_id
- 1);
4254 CPU_SET ((cpu_id
- 1), &cpuset
);
4257 } while ((next
= strtok (NULL
, ",")) != NULL
);
4263 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4264 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4268 pthread_t thread
= pthread_self ();
4269 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4273 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4275 char *element
, *end
;
4277 end
= (char *) base
+ nmemb
* size
;
4279 for (element
= (char *) base
; element
< end
; element
+= size
)
4280 if (!compar (element
, key
))
4286 int sort_by_salt (const void *v1
, const void *v2
)
4288 const salt_t
*s1
= (const salt_t
*) v1
;
4289 const salt_t
*s2
= (const salt_t
*) v2
;
4291 const int res1
= s1
->salt_len
- s2
->salt_len
;
4293 if (res1
!= 0) return (res1
);
4295 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4297 if (res2
!= 0) return (res2
);
4305 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4306 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4313 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4314 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4320 int sort_by_salt_buf (const void *v1
, const void *v2
)
4322 const pot_t
*p1
= (const pot_t
*) v1
;
4323 const pot_t
*p2
= (const pot_t
*) v2
;
4325 const hash_t
*h1
= &p1
->hash
;
4326 const hash_t
*h2
= &p2
->hash
;
4328 const salt_t
*s1
= h1
->salt
;
4329 const salt_t
*s2
= h2
->salt
;
4335 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4336 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4342 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4344 const hash_t
*h1
= (const hash_t
*) v1
;
4345 const hash_t
*h2
= (const hash_t
*) v2
;
4347 const salt_t
*s1
= h1
->salt
;
4348 const salt_t
*s2
= h2
->salt
;
4350 // testphase: this should work
4355 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4356 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4359 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4360 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4361 if (s1->salt_len > s2->salt_len) return ( 1);
4362 if (s1->salt_len < s2->salt_len) return (-1);
4364 uint n = s1->salt_len;
4368 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4369 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4376 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4378 const hash_t
*h1
= (const hash_t
*) v1
;
4379 const hash_t
*h2
= (const hash_t
*) v2
;
4381 const salt_t
*s1
= h1
->salt
;
4382 const salt_t
*s2
= h2
->salt
;
4384 // 12 - 2 (since last 2 uints contain the digest)
4389 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4390 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4396 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4398 const hash_t
*h1
= (const hash_t
*) v1
;
4399 const hash_t
*h2
= (const hash_t
*) v2
;
4401 const void *d1
= h1
->digest
;
4402 const void *d2
= h2
->digest
;
4404 return data
.sort_by_digest (d1
, d2
);
4407 int sort_by_hash (const void *v1
, const void *v2
)
4409 const hash_t
*h1
= (const hash_t
*) v1
;
4410 const hash_t
*h2
= (const hash_t
*) v2
;
4414 const salt_t
*s1
= h1
->salt
;
4415 const salt_t
*s2
= h2
->salt
;
4417 int res
= sort_by_salt (s1
, s2
);
4419 if (res
!= 0) return (res
);
4422 const void *d1
= h1
->digest
;
4423 const void *d2
= h2
->digest
;
4425 return data
.sort_by_digest (d1
, d2
);
4428 int sort_by_pot (const void *v1
, const void *v2
)
4430 const pot_t
*p1
= (const pot_t
*) v1
;
4431 const pot_t
*p2
= (const pot_t
*) v2
;
4433 const hash_t
*h1
= &p1
->hash
;
4434 const hash_t
*h2
= &p2
->hash
;
4436 return sort_by_hash (h1
, h2
);
4439 int sort_by_mtime (const void *p1
, const void *p2
)
4441 const char **f1
= (const char **) p1
;
4442 const char **f2
= (const char **) p2
;
4444 struct stat s1
; stat (*f1
, &s1
);
4445 struct stat s2
; stat (*f2
, &s2
);
4447 return s2
.st_mtime
- s1
.st_mtime
;
4450 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4452 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4453 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4455 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4458 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4460 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4461 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4463 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4466 int sort_by_stringptr (const void *p1
, const void *p2
)
4468 const char **s1
= (const char **) p1
;
4469 const char **s2
= (const char **) p2
;
4471 return strcmp (*s1
, *s2
);
4474 int sort_by_dictstat (const void *s1
, const void *s2
)
4476 dictstat_t
*d1
= (dictstat_t
*) s1
;
4477 dictstat_t
*d2
= (dictstat_t
*) s2
;
4480 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4482 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4485 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4488 int sort_by_bitmap (const void *p1
, const void *p2
)
4490 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4491 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4493 return b1
->collisions
- b2
->collisions
;
4496 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4498 const uint32_t *d1
= (const uint32_t *) v1
;
4499 const uint32_t *d2
= (const uint32_t *) v2
;
4505 if (d1
[n
] > d2
[n
]) return ( 1);
4506 if (d1
[n
] < d2
[n
]) return (-1);
4512 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4514 const uint32_t *d1
= (const uint32_t *) v1
;
4515 const uint32_t *d2
= (const uint32_t *) v2
;
4521 if (d1
[n
] > d2
[n
]) return ( 1);
4522 if (d1
[n
] < d2
[n
]) return (-1);
4528 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4530 const uint32_t *d1
= (const uint32_t *) v1
;
4531 const uint32_t *d2
= (const uint32_t *) v2
;
4537 if (d1
[n
] > d2
[n
]) return ( 1);
4538 if (d1
[n
] < d2
[n
]) return (-1);
4544 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4546 const uint32_t *d1
= (const uint32_t *) v1
;
4547 const uint32_t *d2
= (const uint32_t *) v2
;
4553 if (d1
[n
] > d2
[n
]) return ( 1);
4554 if (d1
[n
] < d2
[n
]) return (-1);
4560 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4562 const uint32_t *d1
= (const uint32_t *) v1
;
4563 const uint32_t *d2
= (const uint32_t *) v2
;
4569 if (d1
[n
] > d2
[n
]) return ( 1);
4570 if (d1
[n
] < d2
[n
]) return (-1);
4576 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4578 const uint32_t *d1
= (const uint32_t *) v1
;
4579 const uint32_t *d2
= (const uint32_t *) v2
;
4585 if (d1
[n
] > d2
[n
]) return ( 1);
4586 if (d1
[n
] < d2
[n
]) return (-1);
4592 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4594 const uint32_t *d1
= (const uint32_t *) v1
;
4595 const uint32_t *d2
= (const uint32_t *) v2
;
4601 if (d1
[n
] > d2
[n
]) return ( 1);
4602 if (d1
[n
] < d2
[n
]) return (-1);
4608 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4610 const uint32_t *d1
= (const uint32_t *) v1
;
4611 const uint32_t *d2
= (const uint32_t *) v2
;
4617 if (d1
[n
] > d2
[n
]) return ( 1);
4618 if (d1
[n
] < d2
[n
]) return (-1);
4624 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4626 const uint64_t *d1
= (const uint64_t *) v1
;
4627 const uint64_t *d2
= (const uint64_t *) v2
;
4633 if (d1
[n
] > d2
[n
]) return ( 1);
4634 if (d1
[n
] < d2
[n
]) return (-1);
4640 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4642 const uint64_t *d1
= (const uint64_t *) v1
;
4643 const uint64_t *d2
= (const uint64_t *) v2
;
4649 if (d1
[n
] > d2
[n
]) return ( 1);
4650 if (d1
[n
] < d2
[n
]) return (-1);
4656 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4658 const uint64_t *d1
= (const uint64_t *) v1
;
4659 const uint64_t *d2
= (const uint64_t *) v2
;
4665 if (d1
[n
] > d2
[n
]) return ( 1);
4666 if (d1
[n
] < d2
[n
]) return (-1);
4672 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4674 const uint32_t *d1
= (const uint32_t *) v1
;
4675 const uint32_t *d2
= (const uint32_t *) v2
;
4677 const uint dgst_pos0
= data
.dgst_pos0
;
4678 const uint dgst_pos1
= data
.dgst_pos1
;
4679 const uint dgst_pos2
= data
.dgst_pos2
;
4680 const uint dgst_pos3
= data
.dgst_pos3
;
4682 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4683 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4684 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4685 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4686 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4687 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4688 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4689 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4694 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
)
4696 uint outfile_autohex
= data
.outfile_autohex
;
4698 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4700 FILE *debug_fp
= NULL
;
4702 if (debug_file
!= NULL
)
4704 debug_fp
= fopen (debug_file
, "ab");
4711 if (debug_fp
== NULL
)
4713 log_info ("WARNING: Could not open debug-file for writing");
4717 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4719 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4721 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4724 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4726 if (debug_mode
== 4)
4728 fputc (':', debug_fp
);
4730 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4733 fputc ('\n', debug_fp
);
4735 if (debug_file
!= NULL
) fclose (debug_fp
);
4739 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4741 int needs_hexify
= 0;
4743 if (outfile_autohex
== 1)
4745 for (uint i
= 0; i
< plain_len
; i
++)
4747 if (plain_ptr
[i
] < 0x20)
4754 if (plain_ptr
[i
] > 0x7f)
4763 if (needs_hexify
== 1)
4765 fprintf (fp
, "$HEX[");
4767 for (uint i
= 0; i
< plain_len
; i
++)
4769 fprintf (fp
, "%02x", plain_ptr
[i
]);
4776 fwrite (plain_ptr
, plain_len
, 1, fp
);
4780 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
)
4782 uint outfile_format
= data
.outfile_format
;
4784 char separator
= data
.separator
;
4786 if (outfile_format
& OUTFILE_FMT_HASH
)
4788 fprintf (out_fp
, "%s", out_buf
);
4790 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4792 fputc (separator
, out_fp
);
4795 else if (data
.username
)
4797 if (username
!= NULL
)
4799 for (uint i
= 0; i
< user_len
; i
++)
4801 fprintf (out_fp
, "%c", username
[i
]);
4804 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4806 fputc (separator
, out_fp
);
4811 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4813 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4815 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4817 fputc (separator
, out_fp
);
4821 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4823 for (uint i
= 0; i
< plain_len
; i
++)
4825 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4828 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4830 fputc (separator
, out_fp
);
4834 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4837 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4842 fprintf (out_fp
, "%lu", crackpos
);
4844 fprintf (out_fp
, "%llu", crackpos
);
4849 fputc ('\n', out_fp
);
4852 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
)
4856 pot_key
.hash
.salt
= hashes_buf
->salt
;
4857 pot_key
.hash
.digest
= hashes_buf
->digest
;
4859 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4865 input_buf
[input_len
] = 0;
4868 unsigned char *username
= NULL
;
4873 user_t
*user
= hashes_buf
->hash_info
->user
;
4877 username
= (unsigned char *) (user
->user_name
);
4879 user_len
= user
->user_len
;
4883 // do output the line
4884 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4888 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4889 #define LM_MASKED_PLAIN "[notfound]"
4891 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
)
4897 pot_left_key
.hash
.salt
= hash_left
->salt
;
4898 pot_left_key
.hash
.digest
= hash_left
->digest
;
4900 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4904 uint weak_hash_found
= 0;
4906 pot_t pot_right_key
;
4908 pot_right_key
.hash
.salt
= hash_right
->salt
;
4909 pot_right_key
.hash
.digest
= hash_right
->digest
;
4911 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4913 if (pot_right_ptr
== NULL
)
4915 // special case, if "weak hash"
4917 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4919 weak_hash_found
= 1;
4921 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4923 // in theory this is not needed, but we are paranoia:
4925 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4926 pot_right_ptr
->plain_len
= 0;
4930 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4932 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
4937 // at least one half was found:
4941 input_buf
[input_len
] = 0;
4945 unsigned char *username
= NULL
;
4950 user_t
*user
= hash_left
->hash_info
->user
;
4954 username
= (unsigned char *) (user
->user_name
);
4956 user_len
= user
->user_len
;
4960 // mask the part which was not found
4962 uint left_part_masked
= 0;
4963 uint right_part_masked
= 0;
4965 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4967 if (pot_left_ptr
== NULL
)
4969 left_part_masked
= 1;
4971 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4973 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4975 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4976 pot_left_ptr
->plain_len
= mask_plain_len
;
4979 if (pot_right_ptr
== NULL
)
4981 right_part_masked
= 1;
4983 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4985 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4987 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4988 pot_right_ptr
->plain_len
= mask_plain_len
;
4991 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4995 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4997 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4999 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5001 // do output the line
5003 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5005 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5007 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5008 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5011 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
)
5015 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5017 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 if (pot_ptr
== NULL
)
5023 input_buf
[input_len
] = 0;
5025 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5029 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
)
5035 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5037 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5041 pot_t pot_right_key
;
5043 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5045 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5047 uint weak_hash_found
= 0;
5049 if (pot_right_ptr
== NULL
)
5051 // special case, if "weak hash"
5053 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5055 weak_hash_found
= 1;
5057 // we just need that pot_right_ptr is not a NULL pointer
5059 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5063 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5065 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5070 // ... at least one part was not cracked
5074 input_buf
[input_len
] = 0;
5076 // only show the hash part which is still not cracked
5078 uint user_len
= input_len
- 32;
5080 char hash_output
[user_len
+ 33];
5082 memset (hash_output
, 0, sizeof (hash_output
));
5084 memcpy (hash_output
, input_buf
, input_len
);
5086 if (pot_left_ptr
!= NULL
)
5088 // only show right part (because left part was already found)
5090 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5092 hash_output
[user_len
+ 16] = 0;
5095 if (pot_right_ptr
!= NULL
)
5097 // only show left part (because right part was already found)
5099 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5101 hash_output
[user_len
+ 16] = 0;
5104 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5106 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5109 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5111 cl_device_type device_types_filter
= 0;
5113 if (opencl_device_types
)
5115 char *device_types
= strdup (opencl_device_types
);
5117 char *next
= strtok (device_types
, ",");
5121 int device_type
= atoi (next
);
5123 if (device_type
< 1 || device_type
> 3)
5125 log_error ("ERROR: invalid device_type %u specified", device_type
);
5130 device_types_filter
|= 1 << device_type
;
5132 } while ((next
= strtok (NULL
, ",")) != NULL
);
5134 free (device_types
);
5138 device_types_filter
= CL_DEVICE_TYPE_ALL
;
5141 return device_types_filter
;
5144 uint
devices_to_devicemask (char *opencl_devices
)
5146 uint opencl_devicemask
= 0;
5150 char *devices
= strdup (opencl_devices
);
5152 char *next
= strtok (devices
, ",");
5156 uint device_id
= atoi (next
);
5158 if (device_id
< 1 || device_id
> 8)
5160 log_error ("ERROR: invalid device_id %u specified", device_id
);
5165 opencl_devicemask
|= 1 << (device_id
- 1);
5167 } while ((next
= strtok (NULL
, ",")) != NULL
);
5172 return opencl_devicemask
;
5175 uint
get_random_num (uint min
, uint max
)
5177 if (min
== max
) return (min
);
5179 return (uint
) ((rand () % (max
- min
)) + min
);
5182 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5184 uint32_t quotient
= dividend
/ divisor
;
5186 if (dividend
% divisor
) quotient
++;
5191 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5193 uint64_t quotient
= dividend
/ divisor
;
5195 if (dividend
% divisor
) quotient
++;
5200 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5202 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5203 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5205 if (tm
->tm_year
- 70)
5207 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5208 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5210 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5212 else if (tm
->tm_yday
)
5214 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5215 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5217 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5219 else if (tm
->tm_hour
)
5221 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5222 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5224 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5226 else if (tm
->tm_min
)
5228 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5229 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5231 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5235 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5237 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5241 void format_speed_display (float val
, char *buf
, size_t len
)
5252 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5263 /* generate output */
5267 snprintf (buf
, len
- 1, "%.0f ", val
);
5271 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5275 void lowercase (char *buf
, int len
)
5277 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5280 void uppercase (char *buf
, int len
)
5282 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5285 int fgetl (FILE *fp
, char *line_buf
)
5291 const int c
= fgetc (fp
);
5293 if (c
== EOF
) break;
5295 line_buf
[line_len
] = (char) c
;
5299 if (line_len
== BUFSIZ
) line_len
--;
5301 if (c
== '\n') break;
5304 if (line_len
== 0) return 0;
5306 if (line_buf
[line_len
- 1] == '\n')
5310 line_buf
[line_len
] = 0;
5313 if (line_len
== 0) return 0;
5315 if (line_buf
[line_len
- 1] == '\r')
5319 line_buf
[line_len
] = 0;
5325 int in_superchop (char *buf
)
5327 int len
= strlen (buf
);
5331 if (buf
[len
- 1] == '\n')
5338 if (buf
[len
- 1] == '\r')
5353 char **scan_directory (const char *path
)
5355 char *tmp_path
= mystrdup (path
);
5357 size_t tmp_path_len
= strlen (tmp_path
);
5359 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5361 tmp_path
[tmp_path_len
- 1] = 0;
5363 tmp_path_len
= strlen (tmp_path
);
5366 char **files
= NULL
;
5372 if ((d
= opendir (tmp_path
)) != NULL
)
5376 while ((de
= readdir (d
)) != NULL
)
5378 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5380 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5382 char *path_file
= (char *) mymalloc (path_size
+ 1);
5384 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5386 path_file
[path_size
] = 0;
5390 if ((d_test
= opendir (path_file
)) != NULL
)
5398 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5402 files
[num_files
- 1] = path_file
;
5408 else if (errno
== ENOTDIR
)
5410 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5414 files
[num_files
- 1] = mystrdup (path
);
5417 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5421 files
[num_files
- 1] = NULL
;
5428 int count_dictionaries (char **dictionary_files
)
5430 if (dictionary_files
== NULL
) return 0;
5434 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5442 char *stroptitype (const uint opti_type
)
5446 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5447 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5448 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5449 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5450 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5451 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5452 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5453 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5454 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5455 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5456 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5457 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5458 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5459 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5465 char *strparser (const uint parser_status
)
5467 switch (parser_status
)
5469 case PARSER_OK
: return ((char *) PA_000
); break;
5470 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5471 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5472 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5473 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5474 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5475 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5476 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5477 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5478 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5479 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5480 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5481 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5482 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5483 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5484 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5485 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5488 return ((char *) PA_255
);
5491 char *strhashtype (const uint hash_mode
)
5495 case 0: return ((char *) HT_00000
); break;
5496 case 10: return ((char *) HT_00010
); break;
5497 case 11: return ((char *) HT_00011
); break;
5498 case 12: return ((char *) HT_00012
); break;
5499 case 20: return ((char *) HT_00020
); break;
5500 case 21: return ((char *) HT_00021
); break;
5501 case 22: return ((char *) HT_00022
); break;
5502 case 23: return ((char *) HT_00023
); break;
5503 case 30: return ((char *) HT_00030
); break;
5504 case 40: return ((char *) HT_00040
); break;
5505 case 50: return ((char *) HT_00050
); break;
5506 case 60: return ((char *) HT_00060
); break;
5507 case 100: return ((char *) HT_00100
); break;
5508 case 101: return ((char *) HT_00101
); break;
5509 case 110: return ((char *) HT_00110
); break;
5510 case 111: return ((char *) HT_00111
); break;
5511 case 112: return ((char *) HT_00112
); break;
5512 case 120: return ((char *) HT_00120
); break;
5513 case 121: return ((char *) HT_00121
); break;
5514 case 122: return ((char *) HT_00122
); break;
5515 case 124: return ((char *) HT_00124
); break;
5516 case 130: return ((char *) HT_00130
); break;
5517 case 131: return ((char *) HT_00131
); break;
5518 case 132: return ((char *) HT_00132
); break;
5519 case 133: return ((char *) HT_00133
); break;
5520 case 140: return ((char *) HT_00140
); break;
5521 case 141: return ((char *) HT_00141
); break;
5522 case 150: return ((char *) HT_00150
); break;
5523 case 160: return ((char *) HT_00160
); break;
5524 case 190: return ((char *) HT_00190
); break;
5525 case 200: return ((char *) HT_00200
); break;
5526 case 300: return ((char *) HT_00300
); break;
5527 case 400: return ((char *) HT_00400
); break;
5528 case 500: return ((char *) HT_00500
); break;
5529 case 501: return ((char *) HT_00501
); break;
5530 case 900: return ((char *) HT_00900
); break;
5531 case 910: return ((char *) HT_00910
); break;
5532 case 1000: return ((char *) HT_01000
); break;
5533 case 1100: return ((char *) HT_01100
); break;
5534 case 1400: return ((char *) HT_01400
); break;
5535 case 1410: return ((char *) HT_01410
); break;
5536 case 1420: return ((char *) HT_01420
); break;
5537 case 1421: return ((char *) HT_01421
); break;
5538 case 1430: return ((char *) HT_01430
); break;
5539 case 1440: return ((char *) HT_01440
); break;
5540 case 1441: return ((char *) HT_01441
); break;
5541 case 1450: return ((char *) HT_01450
); break;
5542 case 1460: return ((char *) HT_01460
); break;
5543 case 1500: return ((char *) HT_01500
); break;
5544 case 1600: return ((char *) HT_01600
); break;
5545 case 1700: return ((char *) HT_01700
); break;
5546 case 1710: return ((char *) HT_01710
); break;
5547 case 1711: return ((char *) HT_01711
); break;
5548 case 1720: return ((char *) HT_01720
); break;
5549 case 1722: return ((char *) HT_01722
); break;
5550 case 1730: return ((char *) HT_01730
); break;
5551 case 1731: return ((char *) HT_01731
); break;
5552 case 1740: return ((char *) HT_01740
); break;
5553 case 1750: return ((char *) HT_01750
); break;
5554 case 1760: return ((char *) HT_01760
); break;
5555 case 1800: return ((char *) HT_01800
); break;
5556 case 2100: return ((char *) HT_02100
); break;
5557 case 2400: return ((char *) HT_02400
); break;
5558 case 2410: return ((char *) HT_02410
); break;
5559 case 2500: return ((char *) HT_02500
); break;
5560 case 2600: return ((char *) HT_02600
); break;
5561 case 2611: return ((char *) HT_02611
); break;
5562 case 2612: return ((char *) HT_02612
); break;
5563 case 2711: return ((char *) HT_02711
); break;
5564 case 2811: return ((char *) HT_02811
); break;
5565 case 3000: return ((char *) HT_03000
); break;
5566 case 3100: return ((char *) HT_03100
); break;
5567 case 3200: return ((char *) HT_03200
); break;
5568 case 3710: return ((char *) HT_03710
); break;
5569 case 3711: return ((char *) HT_03711
); break;
5570 case 3800: return ((char *) HT_03800
); break;
5571 case 4300: return ((char *) HT_04300
); break;
5572 case 4400: return ((char *) HT_04400
); break;
5573 case 4500: return ((char *) HT_04500
); break;
5574 case 4700: return ((char *) HT_04700
); break;
5575 case 4800: return ((char *) HT_04800
); break;
5576 case 4900: return ((char *) HT_04900
); break;
5577 case 5000: return ((char *) HT_05000
); break;
5578 case 5100: return ((char *) HT_05100
); break;
5579 case 5200: return ((char *) HT_05200
); break;
5580 case 5300: return ((char *) HT_05300
); break;
5581 case 5400: return ((char *) HT_05400
); break;
5582 case 5500: return ((char *) HT_05500
); break;
5583 case 5600: return ((char *) HT_05600
); break;
5584 case 5700: return ((char *) HT_05700
); break;
5585 case 5800: return ((char *) HT_05800
); break;
5586 case 6000: return ((char *) HT_06000
); break;
5587 case 6100: return ((char *) HT_06100
); break;
5588 case 6211: return ((char *) HT_06211
); break;
5589 case 6212: return ((char *) HT_06212
); break;
5590 case 6213: return ((char *) HT_06213
); break;
5591 case 6221: return ((char *) HT_06221
); break;
5592 case 6222: return ((char *) HT_06222
); break;
5593 case 6223: return ((char *) HT_06223
); break;
5594 case 6231: return ((char *) HT_06231
); break;
5595 case 6232: return ((char *) HT_06232
); break;
5596 case 6233: return ((char *) HT_06233
); break;
5597 case 6241: return ((char *) HT_06241
); break;
5598 case 6242: return ((char *) HT_06242
); break;
5599 case 6243: return ((char *) HT_06243
); break;
5600 case 6300: return ((char *) HT_06300
); break;
5601 case 6400: return ((char *) HT_06400
); break;
5602 case 6500: return ((char *) HT_06500
); break;
5603 case 6600: return ((char *) HT_06600
); break;
5604 case 6700: return ((char *) HT_06700
); break;
5605 case 6800: return ((char *) HT_06800
); break;
5606 case 6900: return ((char *) HT_06900
); break;
5607 case 7100: return ((char *) HT_07100
); break;
5608 case 7200: return ((char *) HT_07200
); break;
5609 case 7300: return ((char *) HT_07300
); break;
5610 case 7400: return ((char *) HT_07400
); break;
5611 case 7500: return ((char *) HT_07500
); break;
5612 case 7600: return ((char *) HT_07600
); break;
5613 case 7700: return ((char *) HT_07700
); break;
5614 case 7800: return ((char *) HT_07800
); break;
5615 case 7900: return ((char *) HT_07900
); break;
5616 case 8000: return ((char *) HT_08000
); break;
5617 case 8100: return ((char *) HT_08100
); break;
5618 case 8200: return ((char *) HT_08200
); break;
5619 case 8300: return ((char *) HT_08300
); break;
5620 case 8400: return ((char *) HT_08400
); break;
5621 case 8500: return ((char *) HT_08500
); break;
5622 case 8600: return ((char *) HT_08600
); break;
5623 case 8700: return ((char *) HT_08700
); break;
5624 case 8800: return ((char *) HT_08800
); break;
5625 case 8900: return ((char *) HT_08900
); break;
5626 case 9000: return ((char *) HT_09000
); break;
5627 case 9100: return ((char *) HT_09100
); break;
5628 case 9200: return ((char *) HT_09200
); break;
5629 case 9300: return ((char *) HT_09300
); break;
5630 case 9400: return ((char *) HT_09400
); break;
5631 case 9500: return ((char *) HT_09500
); break;
5632 case 9600: return ((char *) HT_09600
); break;
5633 case 9700: return ((char *) HT_09700
); break;
5634 case 9710: return ((char *) HT_09710
); break;
5635 case 9720: return ((char *) HT_09720
); break;
5636 case 9800: return ((char *) HT_09800
); break;
5637 case 9810: return ((char *) HT_09810
); break;
5638 case 9820: return ((char *) HT_09820
); break;
5639 case 9900: return ((char *) HT_09900
); break;
5640 case 10000: return ((char *) HT_10000
); break;
5641 case 10100: return ((char *) HT_10100
); break;
5642 case 10200: return ((char *) HT_10200
); break;
5643 case 10300: return ((char *) HT_10300
); break;
5644 case 10400: return ((char *) HT_10400
); break;
5645 case 10410: return ((char *) HT_10410
); break;
5646 case 10420: return ((char *) HT_10420
); break;
5647 case 10500: return ((char *) HT_10500
); break;
5648 case 10600: return ((char *) HT_10600
); break;
5649 case 10700: return ((char *) HT_10700
); break;
5650 case 10800: return ((char *) HT_10800
); break;
5651 case 10900: return ((char *) HT_10900
); break;
5652 case 11000: return ((char *) HT_11000
); break;
5653 case 11100: return ((char *) HT_11100
); break;
5654 case 11200: return ((char *) HT_11200
); break;
5655 case 11300: return ((char *) HT_11300
); break;
5656 case 11400: return ((char *) HT_11400
); break;
5657 case 11500: return ((char *) HT_11500
); break;
5658 case 11600: return ((char *) HT_11600
); break;
5659 case 11700: return ((char *) HT_11700
); break;
5660 case 11800: return ((char *) HT_11800
); break;
5661 case 11900: return ((char *) HT_11900
); break;
5662 case 12000: return ((char *) HT_12000
); break;
5663 case 12100: return ((char *) HT_12100
); break;
5664 case 12200: return ((char *) HT_12200
); break;
5665 case 12300: return ((char *) HT_12300
); break;
5666 case 12400: return ((char *) HT_12400
); break;
5667 case 12500: return ((char *) HT_12500
); break;
5668 case 12600: return ((char *) HT_12600
); break;
5669 case 12700: return ((char *) HT_12700
); break;
5670 case 12800: return ((char *) HT_12800
); break;
5671 case 12900: return ((char *) HT_12900
); break;
5672 case 13000: return ((char *) HT_13000
); break;
5675 return ((char *) "Unknown");
5678 char *strstatus (const uint devices_status
)
5680 switch (devices_status
)
5682 case STATUS_INIT
: return ((char *) ST_0000
); break;
5683 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5684 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5685 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5686 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5687 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5688 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5689 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5690 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5691 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5694 return ((char *) "Unknown");
5697 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5699 uint hash_type
= data
.hash_type
;
5700 uint hash_mode
= data
.hash_mode
;
5701 uint salt_type
= data
.salt_type
;
5702 uint opts_type
= data
.opts_type
;
5703 uint opti_type
= data
.opti_type
;
5704 uint dgst_size
= data
.dgst_size
;
5706 char *hashfile
= data
.hashfile
;
5710 uint digest_buf
[64];
5712 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5714 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5716 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5718 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5724 case HASH_TYPE_DESCRYPT
:
5725 FP (digest_buf
[1], digest_buf
[0], tt
);
5728 case HASH_TYPE_DESRACF
:
5729 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5730 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5732 FP (digest_buf
[1], digest_buf
[0], tt
);
5736 FP (digest_buf
[1], digest_buf
[0], tt
);
5739 case HASH_TYPE_NETNTLM
:
5740 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5741 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5742 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5743 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5745 FP (digest_buf
[1], digest_buf
[0], tt
);
5746 FP (digest_buf
[3], digest_buf
[2], tt
);
5749 case HASH_TYPE_BSDICRYPT
:
5750 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5751 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5753 FP (digest_buf
[1], digest_buf
[0], tt
);
5758 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5763 digest_buf
[0] += MD4M_A
;
5764 digest_buf
[1] += MD4M_B
;
5765 digest_buf
[2] += MD4M_C
;
5766 digest_buf
[3] += MD4M_D
;
5770 digest_buf
[0] += MD5M_A
;
5771 digest_buf
[1] += MD5M_B
;
5772 digest_buf
[2] += MD5M_C
;
5773 digest_buf
[3] += MD5M_D
;
5776 case HASH_TYPE_SHA1
:
5777 digest_buf
[0] += SHA1M_A
;
5778 digest_buf
[1] += SHA1M_B
;
5779 digest_buf
[2] += SHA1M_C
;
5780 digest_buf
[3] += SHA1M_D
;
5781 digest_buf
[4] += SHA1M_E
;
5784 case HASH_TYPE_SHA256
:
5785 digest_buf
[0] += SHA256M_A
;
5786 digest_buf
[1] += SHA256M_B
;
5787 digest_buf
[2] += SHA256M_C
;
5788 digest_buf
[3] += SHA256M_D
;
5789 digest_buf
[4] += SHA256M_E
;
5790 digest_buf
[5] += SHA256M_F
;
5791 digest_buf
[6] += SHA256M_G
;
5792 digest_buf
[7] += SHA256M_H
;
5795 case HASH_TYPE_SHA384
:
5796 digest_buf64
[0] += SHA384M_A
;
5797 digest_buf64
[1] += SHA384M_B
;
5798 digest_buf64
[2] += SHA384M_C
;
5799 digest_buf64
[3] += SHA384M_D
;
5800 digest_buf64
[4] += SHA384M_E
;
5801 digest_buf64
[5] += SHA384M_F
;
5802 digest_buf64
[6] += 0;
5803 digest_buf64
[7] += 0;
5806 case HASH_TYPE_SHA512
:
5807 digest_buf64
[0] += SHA512M_A
;
5808 digest_buf64
[1] += SHA512M_B
;
5809 digest_buf64
[2] += SHA512M_C
;
5810 digest_buf64
[3] += SHA512M_D
;
5811 digest_buf64
[4] += SHA512M_E
;
5812 digest_buf64
[5] += SHA512M_F
;
5813 digest_buf64
[6] += SHA512M_G
;
5814 digest_buf64
[7] += SHA512M_H
;
5819 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5821 if (dgst_size
== DGST_SIZE_4_2
)
5823 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5825 else if (dgst_size
== DGST_SIZE_4_4
)
5827 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5829 else if (dgst_size
== DGST_SIZE_4_5
)
5831 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5833 else if (dgst_size
== DGST_SIZE_4_6
)
5835 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5837 else if (dgst_size
== DGST_SIZE_4_8
)
5839 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5841 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5843 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5845 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5847 else if (hash_type
== HASH_TYPE_SHA384
)
5849 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5851 else if (hash_type
== HASH_TYPE_SHA512
)
5853 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5855 else if (hash_type
== HASH_TYPE_GOST
)
5857 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5860 else if (dgst_size
== DGST_SIZE_4_64
)
5862 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5864 else if (dgst_size
== DGST_SIZE_8_25
)
5866 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5870 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5871 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5872 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5878 memset (&salt
, 0, sizeof (salt_t
));
5880 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5882 char *ptr
= (char *) salt
.salt_buf
;
5884 uint len
= salt
.salt_len
;
5886 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5892 case HASH_TYPE_NETNTLM
:
5894 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5895 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5897 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5903 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5905 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5913 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5915 uint max
= salt
.salt_len
/ 4;
5919 for (uint i
= 0; i
< max
; i
++)
5921 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5925 if (opts_type
& OPTS_TYPE_ST_HEX
)
5929 memset (tmp
, 0, sizeof (tmp
));
5931 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5933 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5938 memcpy (ptr
, tmp
, len
);
5941 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5943 memset (ptr
+ len
, 0, memset_size
);
5945 salt
.salt_len
= len
;
5949 // some modes require special encoding
5952 uint out_buf_plain
[256];
5953 uint out_buf_salt
[256];
5957 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5958 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5960 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5962 char *ptr_plain
= (char *) out_buf_plain
;
5963 char *ptr_salt
= (char *) out_buf_salt
;
5965 if (hash_mode
== 22)
5969 memset (username
, 0, sizeof (username
));
5971 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5973 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5975 uint16_t *ptr
= (uint16_t *) digest_buf
;
5977 tmp_buf
[ 0] = sig
[0];
5978 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5979 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5980 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5981 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5982 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5983 tmp_buf
[ 6] = sig
[1];
5984 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5985 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5986 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5987 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5988 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5989 tmp_buf
[12] = sig
[2];
5990 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5991 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5992 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5993 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5994 tmp_buf
[17] = sig
[3];
5995 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5996 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5997 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5998 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5999 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6000 tmp_buf
[23] = sig
[4];
6001 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6002 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6003 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6004 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6005 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6006 tmp_buf
[29] = sig
[5];
6008 snprintf (out_buf
, len
-1, "%s:%s",
6012 else if (hash_mode
== 23)
6014 // do not show the \nskyper\n part in output
6016 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6018 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6020 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6027 else if (hash_mode
== 101)
6029 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6031 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6032 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6033 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6034 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6035 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6037 memcpy (tmp_buf
, digest_buf
, 20);
6039 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6041 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6043 else if (hash_mode
== 111)
6045 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6047 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6048 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6049 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6050 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6051 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6053 memcpy (tmp_buf
, digest_buf
, 20);
6054 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6056 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
6058 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6060 else if (hash_mode
== 122)
6062 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6063 (unsigned char *) salt
.salt_buf
,
6070 else if (hash_mode
== 124)
6072 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6073 (unsigned char *) salt
.salt_buf
,
6080 else if (hash_mode
== 131)
6082 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6083 (unsigned char *) salt
.salt_buf
,
6091 else if (hash_mode
== 132)
6093 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6094 (unsigned char *) salt
.salt_buf
,
6101 else if (hash_mode
== 133)
6103 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6105 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6106 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6107 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6108 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6109 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6111 memcpy (tmp_buf
, digest_buf
, 20);
6113 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6115 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6117 else if (hash_mode
== 141)
6119 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6121 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6123 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6125 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6127 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6128 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6129 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6130 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6131 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6133 memcpy (tmp_buf
, digest_buf
, 20);
6135 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6139 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6141 else if (hash_mode
== 400)
6143 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6145 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6146 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6147 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6148 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6150 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6152 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6154 else if (hash_mode
== 500)
6156 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6158 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6159 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6160 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6161 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6163 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6165 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6167 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6171 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6174 else if (hash_mode
== 501)
6176 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6178 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6179 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6181 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6183 else if (hash_mode
== 1421)
6185 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6187 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6203 else if (hash_mode
== 1441)
6205 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6207 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6209 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6211 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6213 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6214 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6215 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6216 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6217 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6218 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6219 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6220 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6222 memcpy (tmp_buf
, digest_buf
, 32);
6224 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6228 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6230 else if (hash_mode
== 1500)
6232 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6233 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6234 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6235 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6236 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6238 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6240 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6242 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6243 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6245 memcpy (tmp_buf
, digest_buf
, 8);
6247 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6249 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6253 else if (hash_mode
== 1600)
6255 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6257 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6258 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6259 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6260 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6262 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6264 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6266 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6270 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6273 else if (hash_mode
== 1711)
6275 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6277 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6278 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6279 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6280 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6281 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6282 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6283 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6284 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6286 memcpy (tmp_buf
, digest_buf
, 64);
6287 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6289 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6291 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6293 else if (hash_mode
== 1722)
6295 uint
*ptr
= digest_buf
;
6297 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6298 (unsigned char *) salt
.salt_buf
,
6308 else if (hash_mode
== 1731)
6310 uint
*ptr
= digest_buf
;
6312 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6313 (unsigned char *) salt
.salt_buf
,
6323 else if (hash_mode
== 1800)
6327 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6328 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6329 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6330 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6331 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6332 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6333 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6334 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6336 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6338 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6340 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6344 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6347 else if (hash_mode
== 2100)
6351 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6353 salt
.salt_iter
+ 1);
6355 uint signature_len
= strlen (out_buf
);
6357 pos
+= signature_len
;
6358 len
-= signature_len
;
6360 char *salt_ptr
= (char *) salt
.salt_buf
;
6362 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6364 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6365 byte_swap_32 (digest_buf
[0]),
6366 byte_swap_32 (digest_buf
[1]),
6367 byte_swap_32 (digest_buf
[2]),
6368 byte_swap_32 (digest_buf
[3]));
6370 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6372 memcpy (tmp_buf
, digest_buf
, 16);
6374 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6376 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6377 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6378 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6379 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6381 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6382 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6383 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6384 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6386 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6387 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6388 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6389 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6391 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6392 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6393 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6394 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6396 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6397 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6398 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6399 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6403 else if (hash_mode
== 2500)
6405 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6407 wpa_t
*wpa
= &wpas
[salt_pos
];
6411 char *pke_ptr
= (char *) pke
;
6413 for (uint i
= 0; i
< 25; i
++)
6415 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6418 unsigned char mac1
[6];
6419 unsigned char mac2
[6];
6421 memcpy (mac1
, pke_ptr
+ 23, 6);
6422 memcpy (mac2
, pke_ptr
+ 29, 6);
6424 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6425 (char *) salt
.salt_buf
,
6439 else if (hash_mode
== 4400)
6441 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6442 byte_swap_32 (digest_buf
[0]),
6443 byte_swap_32 (digest_buf
[1]),
6444 byte_swap_32 (digest_buf
[2]),
6445 byte_swap_32 (digest_buf
[3]));
6447 else if (hash_mode
== 4700)
6449 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6450 byte_swap_32 (digest_buf
[0]),
6451 byte_swap_32 (digest_buf
[1]),
6452 byte_swap_32 (digest_buf
[2]),
6453 byte_swap_32 (digest_buf
[3]),
6454 byte_swap_32 (digest_buf
[4]));
6456 else if (hash_mode
== 4800)
6458 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6460 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6465 byte_swap_32 (salt
.salt_buf
[0]),
6466 byte_swap_32 (salt
.salt_buf
[1]),
6467 byte_swap_32 (salt
.salt_buf
[2]),
6468 byte_swap_32 (salt
.salt_buf
[3]),
6471 else if (hash_mode
== 4900)
6473 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6474 byte_swap_32 (digest_buf
[0]),
6475 byte_swap_32 (digest_buf
[1]),
6476 byte_swap_32 (digest_buf
[2]),
6477 byte_swap_32 (digest_buf
[3]),
6478 byte_swap_32 (digest_buf
[4]));
6480 else if (hash_mode
== 5100)
6482 snprintf (out_buf
, len
-1, "%08x%08x",
6486 else if (hash_mode
== 5200)
6488 snprintf (out_buf
, len
-1, "%s", hashfile
);
6490 else if (hash_mode
== 5300)
6492 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6494 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6496 int buf_len
= len
-1;
6500 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6502 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6504 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6506 snprintf (out_buf
, buf_len
, ":");
6512 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6520 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6522 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6524 if ((i
== 0) || (i
== 5))
6526 snprintf (out_buf
, buf_len
, ":");
6532 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6540 for (uint i
= 0; i
< 4; i
++)
6544 snprintf (out_buf
, buf_len
, ":");
6550 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6556 else if (hash_mode
== 5400)
6558 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6560 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6562 int buf_len
= len
-1;
6566 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6568 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6570 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6572 snprintf (out_buf
, buf_len
, ":");
6578 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6586 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6588 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6590 if ((i
== 0) || (i
== 5))
6592 snprintf (out_buf
, buf_len
, ":");
6598 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6606 for (uint i
= 0; i
< 5; i
++)
6610 snprintf (out_buf
, buf_len
, ":");
6616 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6622 else if (hash_mode
== 5500)
6624 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6626 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6629 char domain_buf
[64];
6630 char srvchall_buf
[1024];
6631 char clichall_buf
[1024];
6633 memset (user_buf
, 0, sizeof (user_buf
));
6634 memset (domain_buf
, 0, sizeof (domain_buf
));
6635 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6636 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6638 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6640 char *ptr
= (char *) netntlm
->userdomain_buf
;
6642 user_buf
[i
] = ptr
[j
];
6645 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6647 char *ptr
= (char *) netntlm
->userdomain_buf
;
6649 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6652 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6654 char *ptr
= (char *) netntlm
->chall_buf
;
6656 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6659 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6661 char *ptr
= (char *) netntlm
->chall_buf
;
6663 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6666 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6674 byte_swap_32 (salt
.salt_buf_pc
[0]),
6675 byte_swap_32 (salt
.salt_buf_pc
[1]),
6678 else if (hash_mode
== 5600)
6680 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6682 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6685 char domain_buf
[64];
6686 char srvchall_buf
[1024];
6687 char clichall_buf
[1024];
6689 memset (user_buf
, 0, sizeof (user_buf
));
6690 memset (domain_buf
, 0, sizeof (domain_buf
));
6691 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6692 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6694 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6696 char *ptr
= (char *) netntlm
->userdomain_buf
;
6698 user_buf
[i
] = ptr
[j
];
6701 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6703 char *ptr
= (char *) netntlm
->userdomain_buf
;
6705 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6708 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6710 char *ptr
= (char *) netntlm
->chall_buf
;
6712 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6715 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6717 char *ptr
= (char *) netntlm
->chall_buf
;
6719 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6722 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6732 else if (hash_mode
== 5700)
6734 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6736 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6737 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6738 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6739 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6740 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6741 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6742 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6743 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6745 memcpy (tmp_buf
, digest_buf
, 32);
6747 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6751 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6753 else if (hash_mode
== 5800)
6755 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6756 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6757 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6758 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6759 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6761 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6768 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6770 snprintf (out_buf
, len
-1, "%s", hashfile
);
6772 else if (hash_mode
== 6300)
6774 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6776 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6777 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6778 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6779 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6781 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6783 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6785 else if (hash_mode
== 6400)
6787 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6789 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6791 else if (hash_mode
== 6500)
6793 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6795 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6797 else if (hash_mode
== 6600)
6799 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6801 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6803 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6804 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6806 uint buf_len
= len
- 1;
6808 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6811 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6813 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6818 else if (hash_mode
== 6700)
6820 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6822 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6824 else if (hash_mode
== 6800)
6826 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6828 else if (hash_mode
== 7100)
6830 uint
*ptr
= digest_buf
;
6832 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6834 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6838 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6839 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6840 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6841 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6842 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6843 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6844 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6845 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6847 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",
6848 SIGNATURE_SHA512OSX
,
6850 esalt
[ 0], esalt
[ 1],
6851 esalt
[ 2], esalt
[ 3],
6852 esalt
[ 4], esalt
[ 5],
6853 esalt
[ 6], esalt
[ 7],
6861 ptr
[15], ptr
[14]);
6863 else if (hash_mode
== 7200)
6865 uint
*ptr
= digest_buf
;
6867 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6869 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6873 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6875 len_used
= strlen (out_buf
);
6877 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6879 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6881 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6884 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",
6892 ptr
[15], ptr
[14]);
6894 else if (hash_mode
== 7300)
6896 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6898 rakp_t
*rakp
= &rakps
[salt_pos
];
6900 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6902 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6905 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6912 else if (hash_mode
== 7400)
6914 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6916 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6917 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6918 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6919 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6920 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6921 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6922 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6923 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6925 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6927 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6929 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6933 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6936 else if (hash_mode
== 7500)
6938 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6940 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6942 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6943 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6947 char *ptr_data
= data
;
6949 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6951 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6954 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6956 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6961 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6963 (char *) krb5pa
->user
,
6964 (char *) krb5pa
->realm
,
6965 (char *) krb5pa
->salt
,
6968 else if (hash_mode
== 7700)
6970 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6971 (char *) salt
.salt_buf
,
6975 else if (hash_mode
== 7800)
6977 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6978 (char *) salt
.salt_buf
,
6985 else if (hash_mode
== 7900)
6987 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6991 char *tmp
= (char *) salt
.salt_buf_pc
;
6993 ptr_plain
[42] = tmp
[0];
6999 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7001 else if (hash_mode
== 8000)
7003 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7004 (unsigned char *) salt
.salt_buf
,
7014 else if (hash_mode
== 8100)
7016 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7017 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7019 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7020 (unsigned char *) salt
.salt_buf
,
7027 else if (hash_mode
== 8200)
7029 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7031 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7033 char data_buf
[4096];
7035 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7037 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7040 data_buf
[cloudkey
->data_len
* 2] = 0;
7042 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7043 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7044 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7045 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7046 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7047 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7048 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7049 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7051 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7052 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7053 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7054 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7056 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7072 else if (hash_mode
== 8300)
7076 char digest_buf_c
[33];
7078 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
7080 digest_buf_c
[32] = 0;
7084 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7086 char domain_buf_c
[33];
7088 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7090 for (uint i
= 0; i
< salt_pc_len
; i
++)
7092 const char next
= domain_buf_c
[i
];
7094 domain_buf_c
[i
] = '.';
7099 domain_buf_c
[salt_pc_len
] = 0;
7103 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7105 else if (hash_mode
== 8500)
7107 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7109 else if (hash_mode
== 2612)
7111 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7113 (char *) salt
.salt_buf
,
7119 else if (hash_mode
== 3711)
7121 char *salt_ptr
= (char *) salt
.salt_buf
;
7123 salt_ptr
[salt
.salt_len
- 1] = 0;
7125 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7126 SIGNATURE_MEDIAWIKI_B
,
7133 else if (hash_mode
== 8800)
7135 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7137 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7141 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7143 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7148 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7149 SIGNATURE_ANDROIDFDE
,
7150 byte_swap_32 (salt
.salt_buf
[0]),
7151 byte_swap_32 (salt
.salt_buf
[1]),
7152 byte_swap_32 (salt
.salt_buf
[2]),
7153 byte_swap_32 (salt
.salt_buf
[3]),
7154 byte_swap_32 (digest_buf
[0]),
7155 byte_swap_32 (digest_buf
[1]),
7156 byte_swap_32 (digest_buf
[2]),
7157 byte_swap_32 (digest_buf
[3]),
7160 else if (hash_mode
== 8900)
7162 uint N
= salt
.scrypt_N
;
7163 uint r
= salt
.scrypt_r
;
7164 uint p
= salt
.scrypt_p
;
7166 char base64_salt
[32];
7168 memset (base64_salt
, 0, 32);
7170 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7172 memset (tmp_buf
, 0, 46);
7174 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7175 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7176 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7177 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7178 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7179 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7180 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7181 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7182 digest_buf
[8] = 0; // needed for base64_encode ()
7184 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7186 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7194 else if (hash_mode
== 9000)
7196 snprintf (out_buf
, len
-1, "%s", hashfile
);
7198 else if (hash_mode
== 9200)
7202 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7204 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7206 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7210 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7211 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7212 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7213 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7214 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7215 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7216 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7217 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7218 digest_buf
[8] = 0; // needed for base64_encode ()
7221 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7223 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7224 tmp_buf
[43] = 0; // cut it here
7228 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7230 else if (hash_mode
== 9300)
7232 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7233 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7234 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7235 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7236 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7237 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7238 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7239 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7240 digest_buf
[8] = 0; // needed for base64_encode ()
7243 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7245 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7246 tmp_buf
[43] = 0; // cut it here
7248 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7250 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7252 else if (hash_mode
== 9400)
7254 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7256 office2007_t
*office2007
= &office2007s
[salt_pos
];
7258 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7259 SIGNATURE_OFFICE2007
,
7262 office2007
->keySize
,
7268 office2007
->encryptedVerifier
[0],
7269 office2007
->encryptedVerifier
[1],
7270 office2007
->encryptedVerifier
[2],
7271 office2007
->encryptedVerifier
[3],
7272 office2007
->encryptedVerifierHash
[0],
7273 office2007
->encryptedVerifierHash
[1],
7274 office2007
->encryptedVerifierHash
[2],
7275 office2007
->encryptedVerifierHash
[3],
7276 office2007
->encryptedVerifierHash
[4]);
7278 else if (hash_mode
== 9500)
7280 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7282 office2010_t
*office2010
= &office2010s
[salt_pos
];
7284 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,
7290 office2010
->encryptedVerifier
[0],
7291 office2010
->encryptedVerifier
[1],
7292 office2010
->encryptedVerifier
[2],
7293 office2010
->encryptedVerifier
[3],
7294 office2010
->encryptedVerifierHash
[0],
7295 office2010
->encryptedVerifierHash
[1],
7296 office2010
->encryptedVerifierHash
[2],
7297 office2010
->encryptedVerifierHash
[3],
7298 office2010
->encryptedVerifierHash
[4],
7299 office2010
->encryptedVerifierHash
[5],
7300 office2010
->encryptedVerifierHash
[6],
7301 office2010
->encryptedVerifierHash
[7]);
7303 else if (hash_mode
== 9600)
7305 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7307 office2013_t
*office2013
= &office2013s
[salt_pos
];
7309 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,
7315 office2013
->encryptedVerifier
[0],
7316 office2013
->encryptedVerifier
[1],
7317 office2013
->encryptedVerifier
[2],
7318 office2013
->encryptedVerifier
[3],
7319 office2013
->encryptedVerifierHash
[0],
7320 office2013
->encryptedVerifierHash
[1],
7321 office2013
->encryptedVerifierHash
[2],
7322 office2013
->encryptedVerifierHash
[3],
7323 office2013
->encryptedVerifierHash
[4],
7324 office2013
->encryptedVerifierHash
[5],
7325 office2013
->encryptedVerifierHash
[6],
7326 office2013
->encryptedVerifierHash
[7]);
7328 else if (hash_mode
== 9700)
7330 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7332 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7334 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7335 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7336 byte_swap_32 (salt
.salt_buf
[0]),
7337 byte_swap_32 (salt
.salt_buf
[1]),
7338 byte_swap_32 (salt
.salt_buf
[2]),
7339 byte_swap_32 (salt
.salt_buf
[3]),
7340 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7341 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7342 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7343 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7344 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7345 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7346 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7347 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7349 else if (hash_mode
== 9710)
7351 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7353 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7355 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7356 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7357 byte_swap_32 (salt
.salt_buf
[0]),
7358 byte_swap_32 (salt
.salt_buf
[1]),
7359 byte_swap_32 (salt
.salt_buf
[2]),
7360 byte_swap_32 (salt
.salt_buf
[3]),
7361 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7362 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7363 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7364 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7365 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7366 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7367 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7368 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7370 else if (hash_mode
== 9720)
7372 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7374 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7376 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7378 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7379 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7380 byte_swap_32 (salt
.salt_buf
[0]),
7381 byte_swap_32 (salt
.salt_buf
[1]),
7382 byte_swap_32 (salt
.salt_buf
[2]),
7383 byte_swap_32 (salt
.salt_buf
[3]),
7384 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7385 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7386 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7387 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7388 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7389 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7390 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7391 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7398 else if (hash_mode
== 9800)
7400 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7402 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7404 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7405 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7410 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7411 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7412 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7413 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7414 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7415 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7416 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7417 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7418 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7420 else if (hash_mode
== 9810)
7422 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7424 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7426 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7427 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7432 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7433 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7434 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7435 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7436 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7437 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7438 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7439 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7440 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7442 else if (hash_mode
== 9820)
7444 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7446 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7448 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7450 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7451 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7456 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7457 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7458 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7459 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7460 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7461 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7462 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7463 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7464 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7471 else if (hash_mode
== 10000)
7475 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7477 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7479 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7483 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7484 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7485 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7486 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7487 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7488 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7489 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7490 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7491 digest_buf
[8] = 0; // needed for base64_encode ()
7494 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7496 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7500 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7502 else if (hash_mode
== 10100)
7504 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7509 byte_swap_32 (salt
.salt_buf
[0]),
7510 byte_swap_32 (salt
.salt_buf
[1]),
7511 byte_swap_32 (salt
.salt_buf
[2]),
7512 byte_swap_32 (salt
.salt_buf
[3]));
7514 else if (hash_mode
== 10200)
7516 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7518 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7522 char challenge
[100];
7524 memset (challenge
, 0, sizeof (challenge
));
7526 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7532 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7533 (char *) cram_md5
->user
,
7541 memset (response
, 0, sizeof (response
));
7543 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7545 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7547 else if (hash_mode
== 10300)
7551 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7553 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7554 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7556 uint tmp_len
= 20 + salt
.salt_len
;
7560 char base64_encoded
[100];
7562 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7564 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7566 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7568 else if (hash_mode
== 10400)
7570 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7572 pdf_t
*pdf
= &pdfs
[salt_pos
];
7574 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",
7582 byte_swap_32 (pdf
->id_buf
[0]),
7583 byte_swap_32 (pdf
->id_buf
[1]),
7584 byte_swap_32 (pdf
->id_buf
[2]),
7585 byte_swap_32 (pdf
->id_buf
[3]),
7587 byte_swap_32 (pdf
->u_buf
[0]),
7588 byte_swap_32 (pdf
->u_buf
[1]),
7589 byte_swap_32 (pdf
->u_buf
[2]),
7590 byte_swap_32 (pdf
->u_buf
[3]),
7591 byte_swap_32 (pdf
->u_buf
[4]),
7592 byte_swap_32 (pdf
->u_buf
[5]),
7593 byte_swap_32 (pdf
->u_buf
[6]),
7594 byte_swap_32 (pdf
->u_buf
[7]),
7596 byte_swap_32 (pdf
->o_buf
[0]),
7597 byte_swap_32 (pdf
->o_buf
[1]),
7598 byte_swap_32 (pdf
->o_buf
[2]),
7599 byte_swap_32 (pdf
->o_buf
[3]),
7600 byte_swap_32 (pdf
->o_buf
[4]),
7601 byte_swap_32 (pdf
->o_buf
[5]),
7602 byte_swap_32 (pdf
->o_buf
[6]),
7603 byte_swap_32 (pdf
->o_buf
[7])
7606 else if (hash_mode
== 10410)
7608 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7610 pdf_t
*pdf
= &pdfs
[salt_pos
];
7612 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",
7620 byte_swap_32 (pdf
->id_buf
[0]),
7621 byte_swap_32 (pdf
->id_buf
[1]),
7622 byte_swap_32 (pdf
->id_buf
[2]),
7623 byte_swap_32 (pdf
->id_buf
[3]),
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])
7644 else if (hash_mode
== 10420)
7646 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7648 pdf_t
*pdf
= &pdfs
[salt_pos
];
7650 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7652 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",
7660 byte_swap_32 (pdf
->id_buf
[0]),
7661 byte_swap_32 (pdf
->id_buf
[1]),
7662 byte_swap_32 (pdf
->id_buf
[2]),
7663 byte_swap_32 (pdf
->id_buf
[3]),
7665 byte_swap_32 (pdf
->u_buf
[0]),
7666 byte_swap_32 (pdf
->u_buf
[1]),
7667 byte_swap_32 (pdf
->u_buf
[2]),
7668 byte_swap_32 (pdf
->u_buf
[3]),
7669 byte_swap_32 (pdf
->u_buf
[4]),
7670 byte_swap_32 (pdf
->u_buf
[5]),
7671 byte_swap_32 (pdf
->u_buf
[6]),
7672 byte_swap_32 (pdf
->u_buf
[7]),
7674 byte_swap_32 (pdf
->o_buf
[0]),
7675 byte_swap_32 (pdf
->o_buf
[1]),
7676 byte_swap_32 (pdf
->o_buf
[2]),
7677 byte_swap_32 (pdf
->o_buf
[3]),
7678 byte_swap_32 (pdf
->o_buf
[4]),
7679 byte_swap_32 (pdf
->o_buf
[5]),
7680 byte_swap_32 (pdf
->o_buf
[6]),
7681 byte_swap_32 (pdf
->o_buf
[7]),
7689 else if (hash_mode
== 10500)
7691 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7693 pdf_t
*pdf
= &pdfs
[salt_pos
];
7695 if (pdf
->id_len
== 32)
7697 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",
7705 byte_swap_32 (pdf
->id_buf
[0]),
7706 byte_swap_32 (pdf
->id_buf
[1]),
7707 byte_swap_32 (pdf
->id_buf
[2]),
7708 byte_swap_32 (pdf
->id_buf
[3]),
7709 byte_swap_32 (pdf
->id_buf
[4]),
7710 byte_swap_32 (pdf
->id_buf
[5]),
7711 byte_swap_32 (pdf
->id_buf
[6]),
7712 byte_swap_32 (pdf
->id_buf
[7]),
7714 byte_swap_32 (pdf
->u_buf
[0]),
7715 byte_swap_32 (pdf
->u_buf
[1]),
7716 byte_swap_32 (pdf
->u_buf
[2]),
7717 byte_swap_32 (pdf
->u_buf
[3]),
7718 byte_swap_32 (pdf
->u_buf
[4]),
7719 byte_swap_32 (pdf
->u_buf
[5]),
7720 byte_swap_32 (pdf
->u_buf
[6]),
7721 byte_swap_32 (pdf
->u_buf
[7]),
7723 byte_swap_32 (pdf
->o_buf
[0]),
7724 byte_swap_32 (pdf
->o_buf
[1]),
7725 byte_swap_32 (pdf
->o_buf
[2]),
7726 byte_swap_32 (pdf
->o_buf
[3]),
7727 byte_swap_32 (pdf
->o_buf
[4]),
7728 byte_swap_32 (pdf
->o_buf
[5]),
7729 byte_swap_32 (pdf
->o_buf
[6]),
7730 byte_swap_32 (pdf
->o_buf
[7])
7735 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",
7743 byte_swap_32 (pdf
->id_buf
[0]),
7744 byte_swap_32 (pdf
->id_buf
[1]),
7745 byte_swap_32 (pdf
->id_buf
[2]),
7746 byte_swap_32 (pdf
->id_buf
[3]),
7748 byte_swap_32 (pdf
->u_buf
[0]),
7749 byte_swap_32 (pdf
->u_buf
[1]),
7750 byte_swap_32 (pdf
->u_buf
[2]),
7751 byte_swap_32 (pdf
->u_buf
[3]),
7752 byte_swap_32 (pdf
->u_buf
[4]),
7753 byte_swap_32 (pdf
->u_buf
[5]),
7754 byte_swap_32 (pdf
->u_buf
[6]),
7755 byte_swap_32 (pdf
->u_buf
[7]),
7757 byte_swap_32 (pdf
->o_buf
[0]),
7758 byte_swap_32 (pdf
->o_buf
[1]),
7759 byte_swap_32 (pdf
->o_buf
[2]),
7760 byte_swap_32 (pdf
->o_buf
[3]),
7761 byte_swap_32 (pdf
->o_buf
[4]),
7762 byte_swap_32 (pdf
->o_buf
[5]),
7763 byte_swap_32 (pdf
->o_buf
[6]),
7764 byte_swap_32 (pdf
->o_buf
[7])
7768 else if (hash_mode
== 10600)
7770 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7772 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7773 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7775 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7777 else if (hash_mode
== 10700)
7779 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7781 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7782 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7784 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7786 else if (hash_mode
== 10900)
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
== 11100)
7797 uint32_t salt_challenge
= salt
.salt_buf
[0];
7799 salt_challenge
= byte_swap_32 (salt_challenge
);
7801 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7803 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7804 SIGNATURE_POSTGRESQL_AUTH
,
7812 else if (hash_mode
== 11200)
7814 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7815 SIGNATURE_MYSQL_AUTH
,
7816 (unsigned char *) salt
.salt_buf
,
7823 else if (hash_mode
== 11300)
7825 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7827 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7829 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7830 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7831 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7833 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7834 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7835 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7837 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7839 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7841 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7844 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7846 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7848 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7851 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7853 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7855 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7858 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7859 SIGNATURE_BITCOIN_WALLET
,
7863 (unsigned char *) salt
.salt_buf
,
7871 free (cry_master_buf
);
7873 free (public_key_buf
);
7875 else if (hash_mode
== 11400)
7877 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7879 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7880 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7882 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7884 else if (hash_mode
== 11600)
7886 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7888 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7890 const uint data_len
= seven_zip
->data_len
;
7892 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7894 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7896 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7898 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7901 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7902 SIGNATURE_SEVEN_ZIP
,
7906 (char *) seven_zip
->salt_buf
,
7908 seven_zip
->iv_buf
[0],
7909 seven_zip
->iv_buf
[1],
7910 seven_zip
->iv_buf
[2],
7911 seven_zip
->iv_buf
[3],
7913 seven_zip
->data_len
,
7914 seven_zip
->unpack_size
,
7919 else if (hash_mode
== 11700)
7921 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7931 else if (hash_mode
== 11800)
7933 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7951 else if (hash_mode
== 11900)
7953 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7955 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7956 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7958 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7960 else if (hash_mode
== 12000)
7962 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7964 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7965 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7967 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7969 else if (hash_mode
== 12100)
7971 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7973 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7974 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7976 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7978 else if (hash_mode
== 12200)
7980 uint
*ptr_digest
= digest_buf
;
7981 uint
*ptr_salt
= salt
.salt_buf
;
7983 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7990 else if (hash_mode
== 12300)
7992 uint
*ptr_digest
= digest_buf
;
7993 uint
*ptr_salt
= salt
.salt_buf
;
7995 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",
7996 ptr_digest
[ 0], ptr_digest
[ 1],
7997 ptr_digest
[ 2], ptr_digest
[ 3],
7998 ptr_digest
[ 4], ptr_digest
[ 5],
7999 ptr_digest
[ 6], ptr_digest
[ 7],
8000 ptr_digest
[ 8], ptr_digest
[ 9],
8001 ptr_digest
[10], ptr_digest
[11],
8002 ptr_digest
[12], ptr_digest
[13],
8003 ptr_digest
[14], ptr_digest
[15],
8009 else if (hash_mode
== 12400)
8011 // encode iteration count
8015 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8016 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8017 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8018 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8023 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8024 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8025 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8026 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8031 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8033 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8034 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8036 memcpy (tmp_buf
, digest_buf
, 8);
8038 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
8042 // fill the resulting buffer
8044 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8046 else if (hash_mode
== 12500)
8048 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8050 byte_swap_32 (salt
.salt_buf
[0]),
8051 byte_swap_32 (salt
.salt_buf
[1]),
8057 else if (hash_mode
== 12600)
8059 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8060 digest_buf
[0] + salt
.salt_buf_pc
[0],
8061 digest_buf
[1] + salt
.salt_buf_pc
[1],
8062 digest_buf
[2] + salt
.salt_buf_pc
[2],
8063 digest_buf
[3] + salt
.salt_buf_pc
[3],
8064 digest_buf
[4] + salt
.salt_buf_pc
[4],
8065 digest_buf
[5] + salt
.salt_buf_pc
[5],
8066 digest_buf
[6] + salt
.salt_buf_pc
[6],
8067 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8069 else if (hash_mode
== 12700)
8071 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8073 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8074 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8076 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8078 else if (hash_mode
== 12800)
8080 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
8082 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",
8095 byte_swap_32 (digest_buf
[0]),
8096 byte_swap_32 (digest_buf
[1]),
8097 byte_swap_32 (digest_buf
[2]),
8098 byte_swap_32 (digest_buf
[3]),
8099 byte_swap_32 (digest_buf
[4]),
8100 byte_swap_32 (digest_buf
[5]),
8101 byte_swap_32 (digest_buf
[6]),
8102 byte_swap_32 (digest_buf
[7])
8105 else if (hash_mode
== 12900)
8107 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",
8116 byte_swap_32 (digest_buf
[0]),
8117 byte_swap_32 (digest_buf
[1]),
8118 byte_swap_32 (digest_buf
[2]),
8119 byte_swap_32 (digest_buf
[3]),
8120 byte_swap_32 (digest_buf
[4]),
8121 byte_swap_32 (digest_buf
[5]),
8122 byte_swap_32 (digest_buf
[6]),
8123 byte_swap_32 (digest_buf
[7]),
8130 else if (hash_mode
== 13000)
8132 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8134 rar5_t
*rar5
= &rar5s
[salt_pos
];
8136 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8146 byte_swap_32 (digest_buf
[0]),
8147 byte_swap_32 (digest_buf
[1])
8152 if (hash_type
== HASH_TYPE_MD4
)
8154 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8160 else if (hash_type
== HASH_TYPE_MD5
)
8162 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8168 else if (hash_type
== HASH_TYPE_SHA1
)
8170 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8177 else if (hash_type
== HASH_TYPE_SHA256
)
8179 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8189 else if (hash_type
== HASH_TYPE_SHA384
)
8191 uint
*ptr
= digest_buf
;
8193 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8201 else if (hash_type
== HASH_TYPE_SHA512
)
8203 uint
*ptr
= digest_buf
;
8205 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8215 else if (hash_type
== HASH_TYPE_LM
)
8217 snprintf (out_buf
, len
-1, "%08x%08x",
8221 else if (hash_type
== HASH_TYPE_ORACLEH
)
8223 snprintf (out_buf
, len
-1, "%08X%08X",
8227 else if (hash_type
== HASH_TYPE_BCRYPT
)
8229 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8230 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8232 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8234 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8236 else if (hash_type
== HASH_TYPE_KECCAK
)
8238 uint
*ptr
= digest_buf
;
8240 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",
8268 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8270 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8272 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8279 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8281 digest_buf
[ 0] = digest_buf
[ 0];
8282 digest_buf
[ 1] = digest_buf
[ 1];
8283 digest_buf
[ 2] = digest_buf
[ 2];
8284 digest_buf
[ 3] = digest_buf
[ 3];
8285 digest_buf
[ 4] = digest_buf
[ 4];
8286 digest_buf
[ 5] = digest_buf
[ 5];
8287 digest_buf
[ 6] = digest_buf
[ 6];
8288 digest_buf
[ 7] = digest_buf
[ 7];
8289 digest_buf
[ 8] = digest_buf
[ 8];
8290 digest_buf
[ 9] = digest_buf
[ 9];
8291 digest_buf
[10] = digest_buf
[10];
8292 digest_buf
[11] = digest_buf
[11];
8293 digest_buf
[12] = digest_buf
[12];
8294 digest_buf
[13] = digest_buf
[13];
8295 digest_buf
[14] = digest_buf
[14];
8296 digest_buf
[15] = digest_buf
[15];
8298 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8316 else if (hash_type
== HASH_TYPE_GOST
)
8318 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8328 else if (hash_type
== HASH_TYPE_MYSQL
)
8330 snprintf (out_buf
, len
-1, "%08x%08x",
8334 else if (hash_type
== HASH_TYPE_LOTUS5
)
8336 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8342 else if (hash_type
== HASH_TYPE_LOTUS6
)
8344 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8345 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8346 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8347 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8351 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8352 memcpy (buf
+ 5, digest_buf
, 9);
8356 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8358 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8361 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8363 else if (hash_type
== HASH_TYPE_LOTUS8
)
8367 memset (buf
, 0, sizeof (buf
));
8371 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8377 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8381 buf
[26] = salt
.salt_buf_pc
[0];
8382 buf
[27] = salt
.salt_buf_pc
[1];
8386 memcpy (buf
+ 28, digest_buf
, 8);
8388 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8392 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8394 else if (hash_type
== HASH_TYPE_CRC32
)
8396 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8400 if (salt_type
== SALT_TYPE_INTERN
)
8402 size_t pos
= strlen (out_buf
);
8404 out_buf
[pos
] = data
.separator
;
8406 char *ptr
= (char *) salt
.salt_buf
;
8408 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8410 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8414 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8416 memset (hccap
, 0, sizeof (hccap_t
));
8418 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8420 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8422 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8423 wpa_t
*wpa
= &wpas
[salt_pos
];
8425 hccap
->keyver
= wpa
->keyver
;
8427 hccap
->eapol_size
= wpa
->eapol_size
;
8429 if (wpa
->keyver
!= 1)
8433 for (uint i
= 0; i
< 64; i
++)
8435 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8438 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8442 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8447 for (int i
= 5; i
< 25; i
++)
8449 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8452 char *pke_ptr
= (char *) pke_tmp
;
8454 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8455 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8456 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8457 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8459 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8461 uint dgst_size
= data
.dgst_size
;
8463 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8465 if (wpa
->keyver
!= 1)
8469 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8470 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8471 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8472 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8474 memcpy (hccap
->keymic
, digest_tmp
, 16);
8478 memcpy (hccap
->keymic
, digest_ptr
, 16);
8482 void SuspendThreads ()
8484 if (data
.devices_status
== STATUS_RUNNING
)
8486 hc_timer_set (&data
.timer_paused
);
8488 data
.devices_status
= STATUS_PAUSED
;
8490 log_info ("Paused");
8494 void ResumeThreads ()
8496 if (data
.devices_status
== STATUS_PAUSED
)
8500 hc_timer_get (data
.timer_paused
, ms_paused
);
8502 data
.ms_paused
+= ms_paused
;
8504 data
.devices_status
= STATUS_RUNNING
;
8506 log_info ("Resumed");
8512 if (data
.devices_status
!= STATUS_RUNNING
) return;
8514 data
.devices_status
= STATUS_BYPASS
;
8516 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8519 void stop_at_checkpoint ()
8521 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8523 if (data
.devices_status
!= STATUS_RUNNING
) return;
8526 // this feature only makes sense if --restore-disable was not specified
8528 if (data
.restore_disable
== 1)
8530 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8535 // check if monitoring of Restore Point updates should be enabled or disabled
8537 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8539 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8541 // save the current restore point value
8543 data
.checkpoint_cur_words
= get_lowest_words_done ();
8545 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8549 data
.devices_status
= STATUS_RUNNING
;
8551 // reset the global value for checkpoint checks
8553 data
.checkpoint_cur_words
= 0;
8555 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8561 if (data
.devices_status
== STATUS_INIT
) return;
8562 if (data
.devices_status
== STATUS_STARTING
) return;
8564 data
.devices_status
= STATUS_ABORTED
;
8569 if (data
.devices_status
== STATUS_INIT
) return;
8570 if (data
.devices_status
== STATUS_STARTING
) return;
8572 data
.devices_status
= STATUS_QUIT
;
8575 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8579 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8583 memset (&st
, 0, sizeof (st
));
8585 stat (kernel_file
, &st
);
8587 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8589 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8591 if (num_read
!= (size_t) st
.st_size
)
8593 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8600 buf
[st
.st_size
] = 0;
8602 for (int i
= 0; i
< num_devices
; i
++)
8604 kernel_lengths
[i
] = (size_t) st
.st_size
;
8606 kernel_sources
[i
] = buf
;
8611 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8619 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8621 FILE *fp
= fopen (dst
, "wb");
8623 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8633 restore_data_t
*init_restore (int argc
, char **argv
)
8635 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8637 if (data
.restore_disable
== 0)
8639 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8643 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8647 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8656 char pidbin
[BUFSIZ
];
8661 memset (pidbin
, 0, sizeof (pidbin
));
8663 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8665 FILE *fd
= fopen (pidbin
, "rb");
8669 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8671 pidbin
[pidbin_len
] = 0;
8675 char *argv0_r
= strrchr (argv
[0], '/');
8677 char *pidbin_r
= strrchr (pidbin
, '/');
8679 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8681 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8683 if (strcmp (argv0_r
, pidbin_r
) == 0)
8685 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8692 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8694 char pidbin2
[BUFSIZ
];
8698 memset (pidbin2
, 0, sizeof (pidbin2
));
8700 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8701 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8703 pidbin
[pidbin_len
] = 0;
8704 pidbin2
[pidbin2_len
] = 0;
8708 if (strcmp (pidbin
, pidbin2
) == 0)
8710 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8718 if (rd
->version_bin
< RESTORE_MIN
)
8720 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8727 memset (rd
, 0, sizeof (restore_data_t
));
8729 rd
->version_bin
= VERSION_BIN
;
8732 rd
->pid
= getpid ();
8734 rd
->pid
= GetCurrentProcessId ();
8737 if (getcwd (rd
->cwd
, 255) == NULL
)
8750 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8752 FILE *fp
= fopen (eff_restore_file
, "rb");
8756 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8761 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8763 log_error ("ERROR: cannot read %s", eff_restore_file
);
8768 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8770 for (uint i
= 0; i
< rd
->argc
; i
++)
8774 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8776 log_error ("ERROR: cannot read %s", eff_restore_file
);
8781 size_t len
= strlen (buf
);
8783 if (len
) buf
[len
- 1] = 0;
8785 rd
->argv
[i
] = mystrdup (buf
);
8792 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8796 log_error ("Restore file is corrupted");
8799 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8801 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8803 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8808 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8812 if (chdir (rd
->cwd
))
8814 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8820 uint64_t get_lowest_words_done ()
8822 uint64_t words_cur
= -1;
8824 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8826 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8828 const uint64_t words_done
= device_param
->words_done
;
8830 if (words_done
< words_cur
) words_cur
= words_done
;
8833 // It's possible that a device's workload isn't finished right after a restore-case.
8834 // In that case, this function would return 0 and overwrite the real restore point
8835 // There's also data.words_cur which is set to rd->words_cur but it changes while
8836 // the attack is running therefore we should stick to rd->words_cur.
8837 // Note that -s influences rd->words_cur we should keep a close look on that.
8839 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8844 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8846 uint64_t words_cur
= get_lowest_words_done ();
8848 rd
->words_cur
= words_cur
;
8850 FILE *fp
= fopen (new_restore_file
, "wb");
8854 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8859 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8861 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8866 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8868 for (uint i
= 0; i
< rd
->argc
; i
++)
8870 fprintf (fp
, "%s", rd
->argv
[i
]);
8876 fsync (fileno (fp
));
8881 void cycle_restore ()
8883 const char *eff_restore_file
= data
.eff_restore_file
;
8884 const char *new_restore_file
= data
.new_restore_file
;
8886 restore_data_t
*rd
= data
.rd
;
8888 write_restore (new_restore_file
, rd
);
8892 memset (&st
, 0, sizeof(st
));
8894 if (stat (eff_restore_file
, &st
) == 0)
8896 if (unlink (eff_restore_file
))
8898 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8902 if (rename (new_restore_file
, eff_restore_file
))
8904 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8908 void check_checkpoint ()
8910 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8912 uint64_t words_cur
= get_lowest_words_done ();
8914 if (words_cur
!= data
.checkpoint_cur_words
)
8924 uint
set_kernel_accel (uint hash_mode
)
8928 case 0: return GET_ACCEL (0);
8929 case 10: return GET_ACCEL (10);
8930 case 11: return GET_ACCEL (11);
8931 case 12: return GET_ACCEL (12);
8932 case 20: return GET_ACCEL (20);
8933 case 21: return GET_ACCEL (21);
8934 case 22: return GET_ACCEL (22);
8935 case 23: return GET_ACCEL (23);
8936 case 30: return GET_ACCEL (30);
8937 case 40: return GET_ACCEL (40);
8938 case 50: return GET_ACCEL (50);
8939 case 60: return GET_ACCEL (60);
8940 case 100: return GET_ACCEL (100);
8941 case 101: return GET_ACCEL (101);
8942 case 110: return GET_ACCEL (110);
8943 case 111: return GET_ACCEL (111);
8944 case 112: return GET_ACCEL (112);
8945 case 120: return GET_ACCEL (120);
8946 case 121: return GET_ACCEL (121);
8947 case 122: return GET_ACCEL (122);
8948 case 124: return GET_ACCEL (124);
8949 case 130: return GET_ACCEL (130);
8950 case 131: return GET_ACCEL (131);
8951 case 132: return GET_ACCEL (132);
8952 case 133: return GET_ACCEL (133);
8953 case 140: return GET_ACCEL (140);
8954 case 141: return GET_ACCEL (141);
8955 case 150: return GET_ACCEL (150);
8956 case 160: return GET_ACCEL (160);
8957 case 190: return GET_ACCEL (190);
8958 case 200: return GET_ACCEL (200);
8959 case 300: return GET_ACCEL (300);
8960 case 400: return GET_ACCEL (400);
8961 case 500: return GET_ACCEL (500);
8962 case 501: return GET_ACCEL (501);
8963 case 900: return GET_ACCEL (900);
8964 case 910: return GET_ACCEL (910);
8965 case 1000: return GET_ACCEL (1000);
8966 case 1100: return GET_ACCEL (1100);
8967 case 1400: return GET_ACCEL (1400);
8968 case 1410: return GET_ACCEL (1410);
8969 case 1420: return GET_ACCEL (1420);
8970 case 1421: return GET_ACCEL (1421);
8971 case 1430: return GET_ACCEL (1430);
8972 case 1440: return GET_ACCEL (1440);
8973 case 1441: return GET_ACCEL (1441);
8974 case 1450: return GET_ACCEL (1450);
8975 case 1460: return GET_ACCEL (1460);
8976 case 1500: return GET_ACCEL (1500);
8977 case 1600: return GET_ACCEL (1600);
8978 case 1700: return GET_ACCEL (1700);
8979 case 1710: return GET_ACCEL (1710);
8980 case 1711: return GET_ACCEL (1711);
8981 case 1720: return GET_ACCEL (1720);
8982 case 1722: return GET_ACCEL (1722);
8983 case 1730: return GET_ACCEL (1730);
8984 case 1731: return GET_ACCEL (1731);
8985 case 1740: return GET_ACCEL (1740);
8986 case 1750: return GET_ACCEL (1750);
8987 case 1760: return GET_ACCEL (1760);
8988 case 1800: return GET_ACCEL (1800);
8989 case 2100: return GET_ACCEL (2100);
8990 case 2400: return GET_ACCEL (2400);
8991 case 2410: return GET_ACCEL (2410);
8992 case 2500: return GET_ACCEL (2500);
8993 case 2600: return GET_ACCEL (2600);
8994 case 2611: return GET_ACCEL (2611);
8995 case 2612: return GET_ACCEL (2612);
8996 case 2711: return GET_ACCEL (2711);
8997 case 2811: return GET_ACCEL (2811);
8998 case 3000: return GET_ACCEL (3000);
8999 case 3100: return GET_ACCEL (3100);
9000 case 3200: return GET_ACCEL (3200);
9001 case 3710: return GET_ACCEL (3710);
9002 case 3711: return GET_ACCEL (3711);
9003 case 3800: return GET_ACCEL (3800);
9004 case 4300: return GET_ACCEL (4300);
9005 case 4400: return GET_ACCEL (4400);
9006 case 4500: return GET_ACCEL (4500);
9007 case 4700: return GET_ACCEL (4700);
9008 case 4800: return GET_ACCEL (4800);
9009 case 4900: return GET_ACCEL (4900);
9010 case 5000: return GET_ACCEL (5000);
9011 case 5100: return GET_ACCEL (5100);
9012 case 5200: return GET_ACCEL (5200);
9013 case 5300: return GET_ACCEL (5300);
9014 case 5400: return GET_ACCEL (5400);
9015 case 5500: return GET_ACCEL (5500);
9016 case 5600: return GET_ACCEL (5600);
9017 case 5700: return GET_ACCEL (5700);
9018 case 5800: return GET_ACCEL (5800);
9019 case 6000: return GET_ACCEL (6000);
9020 case 6100: return GET_ACCEL (6100);
9021 case 6211: return GET_ACCEL (6211);
9022 case 6212: return GET_ACCEL (6212);
9023 case 6213: return GET_ACCEL (6213);
9024 case 6221: return GET_ACCEL (6221);
9025 case 6222: return GET_ACCEL (6222);
9026 case 6223: return GET_ACCEL (6223);
9027 case 6231: return GET_ACCEL (6231);
9028 case 6232: return GET_ACCEL (6232);
9029 case 6233: return GET_ACCEL (6233);
9030 case 6241: return GET_ACCEL (6241);
9031 case 6242: return GET_ACCEL (6242);
9032 case 6243: return GET_ACCEL (6243);
9033 case 6300: return GET_ACCEL (6300);
9034 case 6400: return GET_ACCEL (6400);
9035 case 6500: return GET_ACCEL (6500);
9036 case 6600: return GET_ACCEL (6600);
9037 case 6700: return GET_ACCEL (6700);
9038 case 6800: return GET_ACCEL (6800);
9039 case 6900: return GET_ACCEL (6900);
9040 case 7100: return GET_ACCEL (7100);
9041 case 7200: return GET_ACCEL (7200);
9042 case 7300: return GET_ACCEL (7300);
9043 case 7400: return GET_ACCEL (7400);
9044 case 7500: return GET_ACCEL (7500);
9045 case 7600: return GET_ACCEL (7600);
9046 case 7700: return GET_ACCEL (7700);
9047 case 7800: return GET_ACCEL (7800);
9048 case 7900: return GET_ACCEL (7900);
9049 case 8000: return GET_ACCEL (8000);
9050 case 8100: return GET_ACCEL (8100);
9051 case 8200: return GET_ACCEL (8200);
9052 case 8300: return GET_ACCEL (8300);
9053 case 8400: return GET_ACCEL (8400);
9054 case 8500: return GET_ACCEL (8500);
9055 case 8600: return GET_ACCEL (8600);
9056 case 8700: return GET_ACCEL (8700);
9057 case 8800: return GET_ACCEL (8800);
9058 case 8900: return GET_ACCEL (8900);
9059 case 9000: return GET_ACCEL (9000);
9060 case 9100: return GET_ACCEL (9100);
9061 case 9200: return GET_ACCEL (9200);
9062 case 9300: return GET_ACCEL (9300);
9063 case 9400: return GET_ACCEL (9400);
9064 case 9500: return GET_ACCEL (9500);
9065 case 9600: return GET_ACCEL (9600);
9066 case 9700: return GET_ACCEL (9700);
9067 case 9710: return GET_ACCEL (9710);
9068 case 9720: return GET_ACCEL (9720);
9069 case 9800: return GET_ACCEL (9800);
9070 case 9810: return GET_ACCEL (9810);
9071 case 9820: return GET_ACCEL (9820);
9072 case 9900: return GET_ACCEL (9900);
9073 case 10000: return GET_ACCEL (10000);
9074 case 10100: return GET_ACCEL (10100);
9075 case 10200: return GET_ACCEL (10200);
9076 case 10300: return GET_ACCEL (10300);
9077 case 10400: return GET_ACCEL (10400);
9078 case 10410: return GET_ACCEL (10410);
9079 case 10420: return GET_ACCEL (10420);
9080 case 10500: return GET_ACCEL (10500);
9081 case 10600: return GET_ACCEL (10600);
9082 case 10700: return GET_ACCEL (10700);
9083 case 10800: return GET_ACCEL (10800);
9084 case 10900: return GET_ACCEL (10900);
9085 case 11000: return GET_ACCEL (11000);
9086 case 11100: return GET_ACCEL (11100);
9087 case 11200: return GET_ACCEL (11200);
9088 case 11300: return GET_ACCEL (11300);
9089 case 11400: return GET_ACCEL (11400);
9090 case 11500: return GET_ACCEL (11500);
9091 case 11600: return GET_ACCEL (11600);
9092 case 11700: return GET_ACCEL (11700);
9093 case 11800: return GET_ACCEL (11800);
9094 case 11900: return GET_ACCEL (11900);
9095 case 12000: return GET_ACCEL (12000);
9096 case 12100: return GET_ACCEL (12100);
9097 case 12200: return GET_ACCEL (12200);
9098 case 12300: return GET_ACCEL (12300);
9099 case 12400: return GET_ACCEL (12400);
9100 case 12500: return GET_ACCEL (12500);
9101 case 12600: return GET_ACCEL (12600);
9102 case 12700: return GET_ACCEL (12700);
9103 case 12800: return GET_ACCEL (12800);
9104 case 12900: return GET_ACCEL (12900);
9105 case 13000: return GET_ACCEL (13000);
9111 uint
set_kernel_loops (uint hash_mode
)
9115 case 0: return GET_LOOPS (0);
9116 case 10: return GET_LOOPS (10);
9117 case 11: return GET_LOOPS (11);
9118 case 12: return GET_LOOPS (12);
9119 case 20: return GET_LOOPS (20);
9120 case 21: return GET_LOOPS (21);
9121 case 22: return GET_LOOPS (22);
9122 case 23: return GET_LOOPS (23);
9123 case 30: return GET_LOOPS (30);
9124 case 40: return GET_LOOPS (40);
9125 case 50: return GET_LOOPS (50);
9126 case 60: return GET_LOOPS (60);
9127 case 100: return GET_LOOPS (100);
9128 case 101: return GET_LOOPS (101);
9129 case 110: return GET_LOOPS (110);
9130 case 111: return GET_LOOPS (111);
9131 case 112: return GET_LOOPS (112);
9132 case 120: return GET_LOOPS (120);
9133 case 121: return GET_LOOPS (121);
9134 case 122: return GET_LOOPS (122);
9135 case 124: return GET_LOOPS (124);
9136 case 130: return GET_LOOPS (130);
9137 case 131: return GET_LOOPS (131);
9138 case 132: return GET_LOOPS (132);
9139 case 133: return GET_LOOPS (133);
9140 case 140: return GET_LOOPS (140);
9141 case 141: return GET_LOOPS (141);
9142 case 150: return GET_LOOPS (150);
9143 case 160: return GET_LOOPS (160);
9144 case 190: return GET_LOOPS (190);
9145 case 200: return GET_LOOPS (200);
9146 case 300: return GET_LOOPS (300);
9147 case 400: return GET_LOOPS (400);
9148 case 500: return GET_LOOPS (500);
9149 case 501: return GET_LOOPS (501);
9150 case 900: return GET_LOOPS (900);
9151 case 910: return GET_LOOPS (910);
9152 case 1000: return GET_LOOPS (1000);
9153 case 1100: return GET_LOOPS (1100);
9154 case 1400: return GET_LOOPS (1400);
9155 case 1410: return GET_LOOPS (1410);
9156 case 1420: return GET_LOOPS (1420);
9157 case 1421: return GET_LOOPS (1421);
9158 case 1430: return GET_LOOPS (1430);
9159 case 1440: return GET_LOOPS (1440);
9160 case 1441: return GET_LOOPS (1441);
9161 case 1450: return GET_LOOPS (1450);
9162 case 1460: return GET_LOOPS (1460);
9163 case 1500: return GET_LOOPS (1500);
9164 case 1600: return GET_LOOPS (1600);
9165 case 1700: return GET_LOOPS (1700);
9166 case 1710: return GET_LOOPS (1710);
9167 case 1711: return GET_LOOPS (1711);
9168 case 1720: return GET_LOOPS (1720);
9169 case 1722: return GET_LOOPS (1722);
9170 case 1730: return GET_LOOPS (1730);
9171 case 1731: return GET_LOOPS (1731);
9172 case 1740: return GET_LOOPS (1740);
9173 case 1750: return GET_LOOPS (1750);
9174 case 1760: return GET_LOOPS (1760);
9175 case 1800: return GET_LOOPS (1800);
9176 case 2100: return GET_LOOPS (2100);
9177 case 2400: return GET_LOOPS (2400);
9178 case 2410: return GET_LOOPS (2410);
9179 case 2500: return GET_LOOPS (2500);
9180 case 2600: return GET_LOOPS (2600);
9181 case 2611: return GET_LOOPS (2611);
9182 case 2612: return GET_LOOPS (2612);
9183 case 2711: return GET_LOOPS (2711);
9184 case 2811: return GET_LOOPS (2811);
9185 case 3000: return GET_LOOPS (3000);
9186 case 3100: return GET_LOOPS (3100);
9187 case 3200: return GET_LOOPS (3200);
9188 case 3710: return GET_LOOPS (3710);
9189 case 3711: return GET_LOOPS (3711);
9190 case 3800: return GET_LOOPS (3800);
9191 case 4300: return GET_LOOPS (4300);
9192 case 4400: return GET_LOOPS (4400);
9193 case 4500: return GET_LOOPS (4500);
9194 case 4700: return GET_LOOPS (4700);
9195 case 4800: return GET_LOOPS (4800);
9196 case 4900: return GET_LOOPS (4900);
9197 case 5000: return GET_LOOPS (5000);
9198 case 5100: return GET_LOOPS (5100);
9199 case 5200: return GET_LOOPS (5200);
9200 case 5300: return GET_LOOPS (5300);
9201 case 5400: return GET_LOOPS (5400);
9202 case 5500: return GET_LOOPS (5500);
9203 case 5600: return GET_LOOPS (5600);
9204 case 5700: return GET_LOOPS (5700);
9205 case 5800: return GET_LOOPS (5800);
9206 case 6000: return GET_LOOPS (6000);
9207 case 6100: return GET_LOOPS (6100);
9208 case 6211: return GET_LOOPS (6211);
9209 case 6212: return GET_LOOPS (6212);
9210 case 6213: return GET_LOOPS (6213);
9211 case 6221: return GET_LOOPS (6221);
9212 case 6222: return GET_LOOPS (6222);
9213 case 6223: return GET_LOOPS (6223);
9214 case 6231: return GET_LOOPS (6231);
9215 case 6232: return GET_LOOPS (6232);
9216 case 6233: return GET_LOOPS (6233);
9217 case 6241: return GET_LOOPS (6241);
9218 case 6242: return GET_LOOPS (6242);
9219 case 6243: return GET_LOOPS (6243);
9220 case 6300: return GET_LOOPS (6300);
9221 case 6400: return GET_LOOPS (6400);
9222 case 6500: return GET_LOOPS (6500);
9223 case 6600: return GET_LOOPS (6600);
9224 case 6700: return GET_LOOPS (6700);
9225 case 6800: return GET_LOOPS (6800);
9226 case 6900: return GET_LOOPS (6900);
9227 case 7100: return GET_LOOPS (7100);
9228 case 7200: return GET_LOOPS (7200);
9229 case 7300: return GET_LOOPS (7300);
9230 case 7400: return GET_LOOPS (7400);
9231 case 7500: return GET_LOOPS (7500);
9232 case 7600: return GET_LOOPS (7600);
9233 case 7700: return GET_LOOPS (7700);
9234 case 7800: return GET_LOOPS (7800);
9235 case 7900: return GET_LOOPS (7900);
9236 case 8000: return GET_LOOPS (8000);
9237 case 8100: return GET_LOOPS (8100);
9238 case 8200: return GET_LOOPS (8200);
9239 case 8300: return GET_LOOPS (8300);
9240 case 8400: return GET_LOOPS (8400);
9241 case 8500: return GET_LOOPS (8500);
9242 case 8600: return GET_LOOPS (8600);
9243 case 8700: return GET_LOOPS (8700);
9244 case 8800: return GET_LOOPS (8800);
9245 case 8900: return GET_LOOPS (8900);
9246 case 9000: return GET_LOOPS (9000);
9247 case 9100: return GET_LOOPS (9100);
9248 case 9200: return GET_LOOPS (9200);
9249 case 9300: return GET_LOOPS (9300);
9250 case 9400: return GET_LOOPS (9400);
9251 case 9500: return GET_LOOPS (9500);
9252 case 9600: return GET_LOOPS (9600);
9253 case 9700: return GET_LOOPS (9700);
9254 case 9710: return GET_LOOPS (9710);
9255 case 9720: return GET_LOOPS (9720);
9256 case 9800: return GET_LOOPS (9800);
9257 case 9810: return GET_LOOPS (9810);
9258 case 9820: return GET_LOOPS (9820);
9259 case 9900: return GET_LOOPS (9900);
9260 case 10000: return GET_LOOPS (10000);
9261 case 10100: return GET_LOOPS (10100);
9262 case 10200: return GET_LOOPS (10200);
9263 case 10300: return GET_LOOPS (10300);
9264 case 10400: return GET_LOOPS (10400);
9265 case 10410: return GET_LOOPS (10410);
9266 case 10420: return GET_LOOPS (10420);
9267 case 10500: return GET_LOOPS (10500);
9268 case 10600: return GET_LOOPS (10600);
9269 case 10700: return GET_LOOPS (10700);
9270 case 10800: return GET_LOOPS (10800);
9271 case 10900: return GET_LOOPS (10900);
9272 case 11000: return GET_LOOPS (11000);
9273 case 11100: return GET_LOOPS (11100);
9274 case 11200: return GET_LOOPS (11200);
9275 case 11300: return GET_LOOPS (11300);
9276 case 11400: return GET_LOOPS (11400);
9277 case 11500: return GET_LOOPS (11500);
9278 case 11600: return GET_LOOPS (11600);
9279 case 11700: return GET_LOOPS (11700);
9280 case 11800: return GET_LOOPS (11800);
9281 case 11900: return GET_LOOPS (11900);
9282 case 12000: return GET_LOOPS (12000);
9283 case 12100: return GET_LOOPS (12100);
9284 case 12200: return GET_LOOPS (12200);
9285 case 12300: return GET_LOOPS (12300);
9286 case 12400: return GET_LOOPS (12400);
9287 case 12500: return GET_LOOPS (12500);
9288 case 12600: return GET_LOOPS (12600);
9289 case 12700: return GET_LOOPS (12700);
9290 case 12800: return GET_LOOPS (12800);
9291 case 12900: return GET_LOOPS (12900);
9292 case 13000: return GET_LOOPS (13000);
9302 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9306 if (salt_len
> sizeof(tmp
))
9311 memset (tmp
, 0, sizeof (tmp
));
9312 memcpy (tmp
, in
, salt_len
);
9314 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9316 if ((salt_len
% 2) == 0)
9318 uint new_salt_len
= salt_len
/ 2;
9320 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9322 char p0
= tmp
[j
+ 0];
9323 char p1
= tmp
[j
+ 1];
9325 tmp
[i
] = hex_convert (p1
) << 0;
9326 tmp
[i
] |= hex_convert (p0
) << 4;
9329 salt_len
= new_salt_len
;
9336 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9338 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9341 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9343 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9347 uint
*tmp_uint
= (uint
*) tmp
;
9349 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9350 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9351 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9352 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9353 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9354 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9355 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9356 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9357 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9358 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9360 salt_len
= salt_len
* 2;
9368 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9370 lowercase (tmp
, salt_len
);
9373 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9375 uppercase (tmp
, salt_len
);
9378 uint len
= salt_len
;
9380 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9385 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9390 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9392 uint
*tmp_uint
= (uint
*) tmp
;
9398 for (uint i
= 0; i
< max
; i
++)
9400 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9403 // Important: we may need to increase the length of memcpy since
9404 // we don't want to "loose" some swapped bytes (could happen if
9405 // they do not perfectly fit in the 4-byte blocks)
9406 // Memcpy does always copy the bytes in the BE order, but since
9407 // we swapped them, some important bytes could be in positions
9408 // we normally skip with the original len
9410 if (len
% 4) len
+= 4 - (len
% 4);
9413 memcpy (out
, tmp
, len
);
9418 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9420 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9422 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9424 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9426 salt_t
*salt
= hash_buf
->salt
;
9428 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9430 char *iter_pos
= input_buf
+ 4;
9432 salt
->salt_iter
= 1 << atoi (iter_pos
);
9434 char *salt_pos
= strchr (iter_pos
, '$');
9436 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9442 salt
->salt_len
= salt_len
;
9446 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9448 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9450 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9452 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9454 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9455 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9456 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9457 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9459 char *hash_pos
= salt_pos
+ 22;
9461 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9463 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9465 memcpy (digest
, tmp_buf
, 24);
9467 digest
[0] = byte_swap_32 (digest
[0]);
9468 digest
[1] = byte_swap_32 (digest
[1]);
9469 digest
[2] = byte_swap_32 (digest
[2]);
9470 digest
[3] = byte_swap_32 (digest
[3]);
9471 digest
[4] = byte_swap_32 (digest
[4]);
9472 digest
[5] = byte_swap_32 (digest
[5]);
9474 digest
[5] &= ~0xff; // its just 23 not 24 !
9479 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9481 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9483 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9487 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9489 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9491 memcpy (digest
, tmp_buf
, 32);
9493 digest
[0] = byte_swap_32 (digest
[0]);
9494 digest
[1] = byte_swap_32 (digest
[1]);
9495 digest
[2] = byte_swap_32 (digest
[2]);
9496 digest
[3] = byte_swap_32 (digest
[3]);
9497 digest
[4] = byte_swap_32 (digest
[4]);
9498 digest
[5] = byte_swap_32 (digest
[5]);
9499 digest
[6] = byte_swap_32 (digest
[6]);
9500 digest
[7] = byte_swap_32 (digest
[7]);
9502 digest
[0] -= SHA256M_A
;
9503 digest
[1] -= SHA256M_B
;
9504 digest
[2] -= SHA256M_C
;
9505 digest
[3] -= SHA256M_D
;
9506 digest
[4] -= SHA256M_E
;
9507 digest
[5] -= SHA256M_F
;
9508 digest
[6] -= SHA256M_G
;
9509 digest
[7] -= SHA256M_H
;
9514 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9516 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9518 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9520 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9521 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9523 digest
[0] = byte_swap_32 (digest
[0]);
9524 digest
[1] = byte_swap_32 (digest
[1]);
9528 IP (digest
[0], digest
[1], tt
);
9530 digest
[0] = digest
[0];
9531 digest
[1] = digest
[1];
9538 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9540 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9542 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9544 salt_t
*salt
= hash_buf
->salt
;
9546 char *hash_pos
= input_buf
+ 8;
9548 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9549 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9550 digest
[2] = hex_to_uint (&hash_pos
[16]);
9551 digest
[3] = hex_to_uint (&hash_pos
[24]);
9552 digest
[4] = hex_to_uint (&hash_pos
[32]);
9554 digest
[0] -= SHA1M_A
;
9555 digest
[1] -= SHA1M_B
;
9556 digest
[2] -= SHA1M_C
;
9557 digest
[3] -= SHA1M_D
;
9558 digest
[4] -= SHA1M_E
;
9562 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9564 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9566 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9568 salt
->salt_len
= salt_len
;
9573 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9575 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9577 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9579 salt_t
*salt
= hash_buf
->salt
;
9581 char *hash_pos
= input_buf
+ 8;
9583 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9584 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9585 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9586 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9587 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9588 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9589 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9590 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9592 digest
[0] -= SHA512M_A
;
9593 digest
[1] -= SHA512M_B
;
9594 digest
[2] -= SHA512M_C
;
9595 digest
[3] -= SHA512M_D
;
9596 digest
[4] -= SHA512M_E
;
9597 digest
[5] -= SHA512M_F
;
9598 digest
[6] -= SHA512M_G
;
9599 digest
[7] -= SHA512M_H
;
9603 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9605 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9607 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9609 salt
->salt_len
= salt_len
;
9614 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9616 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9618 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9622 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9625 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9627 salt_t
*salt
= hash_buf
->salt
;
9629 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9630 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9631 digest
[2] = hex_to_uint (&input_buf
[16]);
9632 digest
[3] = hex_to_uint (&input_buf
[24]);
9634 digest
[0] = byte_swap_32 (digest
[0]);
9635 digest
[1] = byte_swap_32 (digest
[1]);
9636 digest
[2] = byte_swap_32 (digest
[2]);
9637 digest
[3] = byte_swap_32 (digest
[3]);
9639 digest
[0] -= MD5M_A
;
9640 digest
[1] -= MD5M_B
;
9641 digest
[2] -= MD5M_C
;
9642 digest
[3] -= MD5M_D
;
9644 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9646 uint salt_len
= input_len
- 32 - 1;
9648 char *salt_buf
= input_buf
+ 32 + 1;
9650 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9652 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9654 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9656 salt
->salt_len
= salt_len
;
9661 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9663 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9665 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9669 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9674 char clean_input_buf
[32];
9676 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9677 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9679 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9683 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9689 clean_input_buf
[k
] = input_buf
[i
];
9697 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9699 salt_t
*salt
= hash_buf
->salt
;
9701 char a
, b
, c
, d
, e
, f
;
9703 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9704 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9705 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9706 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9707 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9708 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9710 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9711 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9713 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9714 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9715 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9716 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9717 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9718 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9720 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9721 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9723 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9724 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9725 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9726 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9727 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9728 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9730 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9731 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9733 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9734 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9735 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9736 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9737 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9738 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9740 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9741 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9743 digest
[0] = byte_swap_32 (digest
[0]);
9744 digest
[1] = byte_swap_32 (digest
[1]);
9745 digest
[2] = byte_swap_32 (digest
[2]);
9746 digest
[3] = byte_swap_32 (digest
[3]);
9748 digest
[0] -= MD5M_A
;
9749 digest
[1] -= MD5M_B
;
9750 digest
[2] -= MD5M_C
;
9751 digest
[3] -= MD5M_D
;
9753 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9755 uint salt_len
= input_len
- 30 - 1;
9757 char *salt_buf
= input_buf
+ 30 + 1;
9759 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9761 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9763 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9764 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9766 salt
->salt_len
= salt_len
;
9768 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9770 salt
->salt_len
+= 22;
9775 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9777 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9779 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9783 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9786 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9788 salt_t
*salt
= hash_buf
->salt
;
9790 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9791 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9792 digest
[2] = hex_to_uint (&input_buf
[16]);
9793 digest
[3] = hex_to_uint (&input_buf
[24]);
9794 digest
[4] = hex_to_uint (&input_buf
[32]);
9796 digest
[0] -= SHA1M_A
;
9797 digest
[1] -= SHA1M_B
;
9798 digest
[2] -= SHA1M_C
;
9799 digest
[3] -= SHA1M_D
;
9800 digest
[4] -= SHA1M_E
;
9802 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9804 uint salt_len
= input_len
- 40 - 1;
9806 char *salt_buf
= input_buf
+ 40 + 1;
9808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9810 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9812 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9814 salt
->salt_len
= salt_len
;
9819 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9821 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9823 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9827 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9830 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9832 char *iter_pos
= input_buf
+ 6;
9834 salt_t
*salt
= hash_buf
->salt
;
9836 salt
->salt_iter
= atoi (iter_pos
) - 1;
9838 char *salt_pos
= strchr (iter_pos
, '#');
9840 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9844 char *digest_pos
= strchr (salt_pos
, '#');
9846 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9850 uint salt_len
= digest_pos
- salt_pos
- 1;
9852 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9854 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9855 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9856 digest
[2] = hex_to_uint (&digest_pos
[16]);
9857 digest
[3] = hex_to_uint (&digest_pos
[24]);
9859 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9861 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9863 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9865 salt
->salt_len
= salt_len
;
9870 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9872 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9874 salt_t
*salt
= hash_buf
->salt
;
9876 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9880 memcpy (&in
, input_buf
, input_len
);
9882 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9884 memcpy (digest
, in
.keymic
, 16);
9887 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9888 The phrase "Pairwise key expansion"
9889 Access Point Address (Referred to as Authenticator Address AA)
9890 Supplicant Address (referred to as Supplicant Address SA)
9891 Access Point Nonce (referred to as Authenticator Anonce)
9892 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9895 uint salt_len
= strlen (in
.essid
);
9897 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9899 salt
->salt_len
= salt_len
;
9901 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9903 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9905 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9907 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9909 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9910 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9914 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9915 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9918 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9920 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9921 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9925 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9926 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9929 for (int i
= 0; i
< 25; i
++)
9931 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9934 wpa
->keyver
= in
.keyver
;
9936 if (wpa
->keyver
> 255)
9938 log_info ("ATTENTION!");
9939 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9940 log_info (" This could be due to a recent aircrack-ng bug.");
9941 log_info (" The key version was automatically reset to a reasonable value.");
9944 wpa
->keyver
&= 0xff;
9947 wpa
->eapol_size
= in
.eapol_size
;
9949 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9951 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9953 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9955 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9957 if (wpa
->keyver
== 1)
9963 digest
[0] = byte_swap_32 (digest
[0]);
9964 digest
[1] = byte_swap_32 (digest
[1]);
9965 digest
[2] = byte_swap_32 (digest
[2]);
9966 digest
[3] = byte_swap_32 (digest
[3]);
9968 for (int i
= 0; i
< 64; i
++)
9970 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9974 salt
->salt_buf
[10] = digest
[1];
9975 salt
->salt_buf
[11] = digest
[2];
9980 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9982 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9984 salt_t
*salt
= hash_buf
->salt
;
9988 log_error ("Password Safe v2 container not specified");
9993 FILE *fp
= fopen (input_buf
, "rb");
9997 log_error ("%s: %s", input_buf
, strerror (errno
));
10004 uint32_t random
[2];
10006 uint32_t salt
[5]; // unused, but makes better valid check
10007 uint32_t iv
[2]; // unused, but makes better valid check
10013 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10017 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10019 salt
->salt_buf
[0] = buf
.random
[0];
10020 salt
->salt_buf
[1] = buf
.random
[1];
10022 salt
->salt_len
= 8;
10023 salt
->salt_iter
= 1000;
10025 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10026 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10027 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10028 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10029 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10031 return (PARSER_OK
);
10034 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10036 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10038 salt_t
*salt
= hash_buf
->salt
;
10040 if (input_len
== 0)
10042 log_error (".psafe3 not specified");
10047 FILE *fp
= fopen (input_buf
, "rb");
10051 log_error ("%s: %s", input_buf
, strerror (errno
));
10058 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10062 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10064 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10066 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10068 salt
->salt_iter
= in
.iterations
+ 1;
10070 salt
->salt_buf
[0] = in
.salt_buf
[0];
10071 salt
->salt_buf
[1] = in
.salt_buf
[1];
10072 salt
->salt_buf
[2] = in
.salt_buf
[2];
10073 salt
->salt_buf
[3] = in
.salt_buf
[3];
10074 salt
->salt_buf
[4] = in
.salt_buf
[4];
10075 salt
->salt_buf
[5] = in
.salt_buf
[5];
10076 salt
->salt_buf
[6] = in
.salt_buf
[6];
10077 salt
->salt_buf
[7] = in
.salt_buf
[7];
10079 salt
->salt_len
= 32;
10081 digest
[0] = in
.hash_buf
[0];
10082 digest
[1] = in
.hash_buf
[1];
10083 digest
[2] = in
.hash_buf
[2];
10084 digest
[3] = in
.hash_buf
[3];
10085 digest
[4] = in
.hash_buf
[4];
10086 digest
[5] = in
.hash_buf
[5];
10087 digest
[6] = in
.hash_buf
[6];
10088 digest
[7] = in
.hash_buf
[7];
10090 digest
[0] = byte_swap_32 (digest
[0]);
10091 digest
[1] = byte_swap_32 (digest
[1]);
10092 digest
[2] = byte_swap_32 (digest
[2]);
10093 digest
[3] = byte_swap_32 (digest
[3]);
10094 digest
[4] = byte_swap_32 (digest
[4]);
10095 digest
[5] = byte_swap_32 (digest
[5]);
10096 digest
[6] = byte_swap_32 (digest
[6]);
10097 digest
[7] = byte_swap_32 (digest
[7]);
10099 return (PARSER_OK
);
10102 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10104 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10106 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10108 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10110 salt_t
*salt
= hash_buf
->salt
;
10112 char *iter_pos
= input_buf
+ 3;
10114 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10116 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10118 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10120 salt
->salt_iter
= salt_iter
;
10122 char *salt_pos
= iter_pos
+ 1;
10126 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10128 salt
->salt_len
= salt_len
;
10130 char *hash_pos
= salt_pos
+ salt_len
;
10132 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10134 return (PARSER_OK
);
10137 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10139 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10141 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10143 salt_t
*salt
= hash_buf
->salt
;
10145 char *salt_pos
= input_buf
+ 3;
10147 uint iterations_len
= 0;
10149 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10153 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10155 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10156 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10160 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10164 iterations_len
+= 8;
10168 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10171 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10173 char *hash_pos
= strchr (salt_pos
, '$');
10175 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10177 uint salt_len
= hash_pos
- salt_pos
;
10179 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10181 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10183 salt
->salt_len
= salt_len
;
10187 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10189 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10191 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10193 return (PARSER_OK
);
10196 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10198 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10200 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10202 salt_t
*salt
= hash_buf
->salt
;
10204 char *salt_pos
= input_buf
+ 6;
10206 uint iterations_len
= 0;
10208 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10212 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10214 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10215 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10219 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10223 iterations_len
+= 8;
10227 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10230 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10232 char *hash_pos
= strchr (salt_pos
, '$');
10234 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10236 uint salt_len
= hash_pos
- salt_pos
;
10238 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10240 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10242 salt
->salt_len
= salt_len
;
10246 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10248 return (PARSER_OK
);
10251 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10253 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10255 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10257 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10259 salt_t
*salt
= hash_buf
->salt
;
10261 char *salt_pos
= input_buf
+ 14;
10263 char *hash_pos
= strchr (salt_pos
, '*');
10265 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10269 uint salt_len
= hash_pos
- salt_pos
- 1;
10271 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10273 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10275 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10277 salt
->salt_len
= salt_len
;
10279 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10281 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10283 memcpy (digest
, tmp_buf
, 20);
10285 digest
[0] = byte_swap_32 (digest
[0]);
10286 digest
[1] = byte_swap_32 (digest
[1]);
10287 digest
[2] = byte_swap_32 (digest
[2]);
10288 digest
[3] = byte_swap_32 (digest
[3]);
10289 digest
[4] = byte_swap_32 (digest
[4]);
10291 digest
[0] -= SHA1M_A
;
10292 digest
[1] -= SHA1M_B
;
10293 digest
[2] -= SHA1M_C
;
10294 digest
[3] -= SHA1M_D
;
10295 digest
[4] -= SHA1M_E
;
10297 return (PARSER_OK
);
10300 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10302 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10304 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10306 if (c12
& 3) return (PARSER_HASH_VALUE
);
10308 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10310 salt_t
*salt
= hash_buf
->salt
;
10312 // for ascii_digest
10313 salt
->salt_sign
[0] = input_buf
[0];
10314 salt
->salt_sign
[1] = input_buf
[1];
10316 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10317 | itoa64_to_int (input_buf
[1]) << 6;
10319 salt
->salt_len
= 2;
10323 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10325 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10327 memcpy (digest
, tmp_buf
, 8);
10331 IP (digest
[0], digest
[1], tt
);
10336 return (PARSER_OK
);
10339 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10341 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10343 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10345 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10346 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10347 digest
[2] = hex_to_uint (&input_buf
[16]);
10348 digest
[3] = hex_to_uint (&input_buf
[24]);
10350 digest
[0] = byte_swap_32 (digest
[0]);
10351 digest
[1] = byte_swap_32 (digest
[1]);
10352 digest
[2] = byte_swap_32 (digest
[2]);
10353 digest
[3] = byte_swap_32 (digest
[3]);
10355 digest
[0] -= MD4M_A
;
10356 digest
[1] -= MD4M_B
;
10357 digest
[2] -= MD4M_C
;
10358 digest
[3] -= MD4M_D
;
10360 return (PARSER_OK
);
10363 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10365 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10367 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10371 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10374 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10376 salt_t
*salt
= hash_buf
->salt
;
10378 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10379 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10380 digest
[2] = hex_to_uint (&input_buf
[16]);
10381 digest
[3] = hex_to_uint (&input_buf
[24]);
10383 digest
[0] = byte_swap_32 (digest
[0]);
10384 digest
[1] = byte_swap_32 (digest
[1]);
10385 digest
[2] = byte_swap_32 (digest
[2]);
10386 digest
[3] = byte_swap_32 (digest
[3]);
10388 digest
[0] -= MD4M_A
;
10389 digest
[1] -= MD4M_B
;
10390 digest
[2] -= MD4M_C
;
10391 digest
[3] -= MD4M_D
;
10393 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10395 uint salt_len
= input_len
- 32 - 1;
10397 char *salt_buf
= input_buf
+ 32 + 1;
10399 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10401 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10403 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10405 salt
->salt_len
= salt_len
;
10407 return (PARSER_OK
);
10410 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10412 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10414 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10416 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10417 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10418 digest
[2] = hex_to_uint (&input_buf
[16]);
10419 digest
[3] = hex_to_uint (&input_buf
[24]);
10421 digest
[0] = byte_swap_32 (digest
[0]);
10422 digest
[1] = byte_swap_32 (digest
[1]);
10423 digest
[2] = byte_swap_32 (digest
[2]);
10424 digest
[3] = byte_swap_32 (digest
[3]);
10426 digest
[0] -= MD5M_A
;
10427 digest
[1] -= MD5M_B
;
10428 digest
[2] -= MD5M_C
;
10429 digest
[3] -= MD5M_D
;
10431 return (PARSER_OK
);
10434 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10436 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10438 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10440 digest
[0] = hex_to_uint (&input_buf
[0]);
10441 digest
[1] = hex_to_uint (&input_buf
[8]);
10445 digest
[0] = byte_swap_32 (digest
[0]);
10446 digest
[1] = byte_swap_32 (digest
[1]);
10448 return (PARSER_OK
);
10451 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10453 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10455 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10459 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10462 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10464 salt_t
*salt
= hash_buf
->salt
;
10466 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10467 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10468 digest
[2] = hex_to_uint (&input_buf
[16]);
10469 digest
[3] = hex_to_uint (&input_buf
[24]);
10471 digest
[0] = byte_swap_32 (digest
[0]);
10472 digest
[1] = byte_swap_32 (digest
[1]);
10473 digest
[2] = byte_swap_32 (digest
[2]);
10474 digest
[3] = byte_swap_32 (digest
[3]);
10476 digest
[0] -= MD5M_A
;
10477 digest
[1] -= MD5M_B
;
10478 digest
[2] -= MD5M_C
;
10479 digest
[3] -= MD5M_D
;
10481 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10483 uint salt_len
= input_len
- 32 - 1;
10485 char *salt_buf
= input_buf
+ 32 + 1;
10487 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10489 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10491 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10493 salt
->salt_len
= salt_len
;
10495 return (PARSER_OK
);
10498 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10500 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10502 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10504 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10505 | itoa64_to_int (input_buf
[ 1]) << 6
10506 | itoa64_to_int (input_buf
[ 2]) << 12
10507 | itoa64_to_int (input_buf
[ 3]) << 18;
10508 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10509 | itoa64_to_int (input_buf
[ 5]) << 6
10510 | itoa64_to_int (input_buf
[ 6]) << 12
10511 | itoa64_to_int (input_buf
[ 7]) << 18;
10512 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10513 | itoa64_to_int (input_buf
[ 9]) << 6
10514 | itoa64_to_int (input_buf
[10]) << 12
10515 | itoa64_to_int (input_buf
[11]) << 18;
10516 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10517 | itoa64_to_int (input_buf
[13]) << 6
10518 | itoa64_to_int (input_buf
[14]) << 12
10519 | itoa64_to_int (input_buf
[15]) << 18;
10521 digest
[0] -= MD5M_A
;
10522 digest
[1] -= MD5M_B
;
10523 digest
[2] -= MD5M_C
;
10524 digest
[3] -= MD5M_D
;
10526 digest
[0] &= 0x00ffffff;
10527 digest
[1] &= 0x00ffffff;
10528 digest
[2] &= 0x00ffffff;
10529 digest
[3] &= 0x00ffffff;
10531 return (PARSER_OK
);
10534 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10536 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10538 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10542 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10545 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10547 salt_t
*salt
= hash_buf
->salt
;
10549 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10550 | itoa64_to_int (input_buf
[ 1]) << 6
10551 | itoa64_to_int (input_buf
[ 2]) << 12
10552 | itoa64_to_int (input_buf
[ 3]) << 18;
10553 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10554 | itoa64_to_int (input_buf
[ 5]) << 6
10555 | itoa64_to_int (input_buf
[ 6]) << 12
10556 | itoa64_to_int (input_buf
[ 7]) << 18;
10557 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10558 | itoa64_to_int (input_buf
[ 9]) << 6
10559 | itoa64_to_int (input_buf
[10]) << 12
10560 | itoa64_to_int (input_buf
[11]) << 18;
10561 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10562 | itoa64_to_int (input_buf
[13]) << 6
10563 | itoa64_to_int (input_buf
[14]) << 12
10564 | itoa64_to_int (input_buf
[15]) << 18;
10566 digest
[0] -= MD5M_A
;
10567 digest
[1] -= MD5M_B
;
10568 digest
[2] -= MD5M_C
;
10569 digest
[3] -= MD5M_D
;
10571 digest
[0] &= 0x00ffffff;
10572 digest
[1] &= 0x00ffffff;
10573 digest
[2] &= 0x00ffffff;
10574 digest
[3] &= 0x00ffffff;
10576 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10578 uint salt_len
= input_len
- 16 - 1;
10580 char *salt_buf
= input_buf
+ 16 + 1;
10582 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10584 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10586 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10588 salt
->salt_len
= salt_len
;
10590 return (PARSER_OK
);
10593 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10595 key
[0] = (nthash
[0] >> 0);
10596 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10597 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10598 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10599 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10600 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10601 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10602 key
[7] = (nthash
[6] << 1);
10614 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10616 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10618 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10620 salt_t
*salt
= hash_buf
->salt
;
10622 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10628 char *user_pos
= input_buf
;
10630 char *unused_pos
= strchr (user_pos
, ':');
10632 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10634 uint user_len
= unused_pos
- user_pos
;
10636 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10640 char *domain_pos
= strchr (unused_pos
, ':');
10642 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10644 uint unused_len
= domain_pos
- unused_pos
;
10646 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10650 char *srvchall_pos
= strchr (domain_pos
, ':');
10652 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10654 uint domain_len
= srvchall_pos
- domain_pos
;
10656 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10660 char *hash_pos
= strchr (srvchall_pos
, ':');
10662 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10664 uint srvchall_len
= hash_pos
- srvchall_pos
;
10666 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10670 char *clichall_pos
= strchr (hash_pos
, ':');
10672 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10674 uint hash_len
= clichall_pos
- hash_pos
;
10676 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10680 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10682 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10685 * store some data for later use
10688 netntlm
->user_len
= user_len
* 2;
10689 netntlm
->domain_len
= domain_len
* 2;
10690 netntlm
->srvchall_len
= srvchall_len
/ 2;
10691 netntlm
->clichall_len
= clichall_len
/ 2;
10693 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10694 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10697 * handle username and domainname
10700 for (uint i
= 0; i
< user_len
; i
++)
10702 *userdomain_ptr
++ = user_pos
[i
];
10703 *userdomain_ptr
++ = 0;
10706 for (uint i
= 0; i
< domain_len
; i
++)
10708 *userdomain_ptr
++ = domain_pos
[i
];
10709 *userdomain_ptr
++ = 0;
10713 * handle server challenge encoding
10716 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10718 const char p0
= srvchall_pos
[i
+ 0];
10719 const char p1
= srvchall_pos
[i
+ 1];
10721 *chall_ptr
++ = hex_convert (p1
) << 0
10722 | hex_convert (p0
) << 4;
10726 * handle client challenge encoding
10729 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10731 const char p0
= clichall_pos
[i
+ 0];
10732 const char p1
= clichall_pos
[i
+ 1];
10734 *chall_ptr
++ = hex_convert (p1
) << 0
10735 | hex_convert (p0
) << 4;
10742 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10744 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10746 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10748 salt
->salt_len
= salt_len
;
10750 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10751 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10752 digest
[2] = hex_to_uint (&hash_pos
[16]);
10753 digest
[3] = hex_to_uint (&hash_pos
[24]);
10755 digest
[0] = byte_swap_32 (digest
[0]);
10756 digest
[1] = byte_swap_32 (digest
[1]);
10757 digest
[2] = byte_swap_32 (digest
[2]);
10758 digest
[3] = byte_swap_32 (digest
[3]);
10760 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10762 uint digest_tmp
[2];
10764 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10765 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10767 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10768 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10770 /* special case 2: ESS */
10772 if (srvchall_len
== 48)
10774 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10778 w
[ 0] = netntlm
->chall_buf
[6];
10779 w
[ 1] = netntlm
->chall_buf
[7];
10780 w
[ 2] = netntlm
->chall_buf
[0];
10781 w
[ 3] = netntlm
->chall_buf
[1];
10804 salt
->salt_buf
[0] = dgst
[0];
10805 salt
->salt_buf
[1] = dgst
[1];
10809 /* precompute netntlmv1 exploit start */
10811 for (uint i
= 0; i
< 0x10000; i
++)
10813 uint key_md4
[2] = { i
, 0 };
10814 uint key_des
[2] = { 0, 0 };
10816 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10821 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10823 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10825 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10827 if (data3
[0] != digest_tmp
[0]) continue;
10828 if (data3
[1] != digest_tmp
[1]) continue;
10830 salt
->salt_buf
[2] = i
;
10832 salt
->salt_len
= 24;
10837 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10838 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10840 /* precompute netntlmv1 exploit stop */
10844 IP (digest
[0], digest
[1], tt
);
10845 IP (digest
[2], digest
[3], tt
);
10847 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10848 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10849 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10850 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10852 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10854 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10855 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10857 return (PARSER_OK
);
10860 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10862 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10864 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10866 salt_t
*salt
= hash_buf
->salt
;
10868 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10874 char *user_pos
= input_buf
;
10876 char *unused_pos
= strchr (user_pos
, ':');
10878 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10880 uint user_len
= unused_pos
- user_pos
;
10882 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10886 char *domain_pos
= strchr (unused_pos
, ':');
10888 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10890 uint unused_len
= domain_pos
- unused_pos
;
10892 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10896 char *srvchall_pos
= strchr (domain_pos
, ':');
10898 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10900 uint domain_len
= srvchall_pos
- domain_pos
;
10902 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10906 char *hash_pos
= strchr (srvchall_pos
, ':');
10908 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10910 uint srvchall_len
= hash_pos
- srvchall_pos
;
10912 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10916 char *clichall_pos
= strchr (hash_pos
, ':');
10918 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10920 uint hash_len
= clichall_pos
- hash_pos
;
10922 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10926 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10928 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10930 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10933 * store some data for later use
10936 netntlm
->user_len
= user_len
* 2;
10937 netntlm
->domain_len
= domain_len
* 2;
10938 netntlm
->srvchall_len
= srvchall_len
/ 2;
10939 netntlm
->clichall_len
= clichall_len
/ 2;
10941 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10942 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10945 * handle username and domainname
10948 for (uint i
= 0; i
< user_len
; i
++)
10950 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10951 *userdomain_ptr
++ = 0;
10954 for (uint i
= 0; i
< domain_len
; i
++)
10956 *userdomain_ptr
++ = domain_pos
[i
];
10957 *userdomain_ptr
++ = 0;
10960 *userdomain_ptr
++ = 0x80;
10963 * handle server challenge encoding
10966 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10968 const char p0
= srvchall_pos
[i
+ 0];
10969 const char p1
= srvchall_pos
[i
+ 1];
10971 *chall_ptr
++ = hex_convert (p1
) << 0
10972 | hex_convert (p0
) << 4;
10976 * handle client challenge encoding
10979 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10981 const char p0
= clichall_pos
[i
+ 0];
10982 const char p1
= clichall_pos
[i
+ 1];
10984 *chall_ptr
++ = hex_convert (p1
) << 0
10985 | hex_convert (p0
) << 4;
10988 *chall_ptr
++ = 0x80;
10991 * handle hash itself
10994 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10995 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10996 digest
[2] = hex_to_uint (&hash_pos
[16]);
10997 digest
[3] = hex_to_uint (&hash_pos
[24]);
10999 digest
[0] = byte_swap_32 (digest
[0]);
11000 digest
[1] = byte_swap_32 (digest
[1]);
11001 digest
[2] = byte_swap_32 (digest
[2]);
11002 digest
[3] = byte_swap_32 (digest
[3]);
11005 * reuse challange data as salt_buf, its the buffer that is most likely unique
11008 salt
->salt_buf
[0] = 0;
11009 salt
->salt_buf
[1] = 0;
11010 salt
->salt_buf
[2] = 0;
11011 salt
->salt_buf
[3] = 0;
11012 salt
->salt_buf
[4] = 0;
11013 salt
->salt_buf
[5] = 0;
11014 salt
->salt_buf
[6] = 0;
11015 salt
->salt_buf
[7] = 0;
11019 uptr
= (uint
*) netntlm
->userdomain_buf
;
11021 for (uint i
= 0; i
< 16; i
+= 16)
11023 md5_64 (uptr
, salt
->salt_buf
);
11026 uptr
= (uint
*) netntlm
->chall_buf
;
11028 for (uint i
= 0; i
< 256; i
+= 16)
11030 md5_64 (uptr
, salt
->salt_buf
);
11033 salt
->salt_len
= 16;
11035 return (PARSER_OK
);
11038 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11040 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11042 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11046 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11049 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11051 salt_t
*salt
= hash_buf
->salt
;
11053 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11054 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11055 digest
[2] = hex_to_uint (&input_buf
[16]);
11056 digest
[3] = hex_to_uint (&input_buf
[24]);
11058 digest
[0] = byte_swap_32 (digest
[0]);
11059 digest
[1] = byte_swap_32 (digest
[1]);
11060 digest
[2] = byte_swap_32 (digest
[2]);
11061 digest
[3] = byte_swap_32 (digest
[3]);
11063 digest
[0] -= MD5M_A
;
11064 digest
[1] -= MD5M_B
;
11065 digest
[2] -= MD5M_C
;
11066 digest
[3] -= MD5M_D
;
11068 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11070 uint salt_len
= input_len
- 32 - 1;
11072 char *salt_buf
= input_buf
+ 32 + 1;
11074 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11076 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11078 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11080 salt
->salt_len
= salt_len
;
11082 return (PARSER_OK
);
11085 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11087 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11089 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11093 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11096 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11098 salt_t
*salt
= hash_buf
->salt
;
11100 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11101 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11102 digest
[2] = hex_to_uint (&input_buf
[16]);
11103 digest
[3] = hex_to_uint (&input_buf
[24]);
11105 digest
[0] = byte_swap_32 (digest
[0]);
11106 digest
[1] = byte_swap_32 (digest
[1]);
11107 digest
[2] = byte_swap_32 (digest
[2]);
11108 digest
[3] = byte_swap_32 (digest
[3]);
11110 digest
[0] -= MD5M_A
;
11111 digest
[1] -= MD5M_B
;
11112 digest
[2] -= MD5M_C
;
11113 digest
[3] -= MD5M_D
;
11115 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11117 uint salt_len
= input_len
- 32 - 1;
11119 char *salt_buf
= input_buf
+ 32 + 1;
11121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11123 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11125 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11127 salt
->salt_len
= salt_len
;
11129 return (PARSER_OK
);
11132 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11134 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11136 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11138 salt_t
*salt
= hash_buf
->salt
;
11140 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11141 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11142 digest
[2] = hex_to_uint (&input_buf
[16]);
11143 digest
[3] = hex_to_uint (&input_buf
[24]);
11145 digest
[0] = byte_swap_32 (digest
[0]);
11146 digest
[1] = byte_swap_32 (digest
[1]);
11147 digest
[2] = byte_swap_32 (digest
[2]);
11148 digest
[3] = byte_swap_32 (digest
[3]);
11150 digest
[0] -= MD5M_A
;
11151 digest
[1] -= MD5M_B
;
11152 digest
[2] -= MD5M_C
;
11153 digest
[3] -= MD5M_D
;
11156 * This is a virtual salt. While the algorithm is basically not salted
11157 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11158 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11161 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11163 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11165 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11167 salt
->salt_len
= salt_len
;
11169 return (PARSER_OK
);
11172 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11174 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11176 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11180 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11183 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11185 salt_t
*salt
= hash_buf
->salt
;
11187 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11188 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11189 digest
[2] = hex_to_uint (&input_buf
[16]);
11190 digest
[3] = hex_to_uint (&input_buf
[24]);
11192 digest
[0] = byte_swap_32 (digest
[0]);
11193 digest
[1] = byte_swap_32 (digest
[1]);
11194 digest
[2] = byte_swap_32 (digest
[2]);
11195 digest
[3] = byte_swap_32 (digest
[3]);
11197 digest
[0] -= MD5M_A
;
11198 digest
[1] -= MD5M_B
;
11199 digest
[2] -= MD5M_C
;
11200 digest
[3] -= MD5M_D
;
11202 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11204 uint salt_len
= input_len
- 32 - 1;
11206 char *salt_buf
= input_buf
+ 32 + 1;
11208 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11210 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11212 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11214 salt
->salt_len
= salt_len
;
11216 return (PARSER_OK
);
11219 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11221 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11223 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11227 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11230 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11232 salt_t
*salt
= hash_buf
->salt
;
11234 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11235 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11236 digest
[2] = hex_to_uint (&input_buf
[16]);
11237 digest
[3] = hex_to_uint (&input_buf
[24]);
11239 digest
[0] = byte_swap_32 (digest
[0]);
11240 digest
[1] = byte_swap_32 (digest
[1]);
11241 digest
[2] = byte_swap_32 (digest
[2]);
11242 digest
[3] = byte_swap_32 (digest
[3]);
11244 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11246 uint salt_len
= input_len
- 32 - 1;
11248 char *salt_buf
= input_buf
+ 32 + 1;
11250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11256 salt
->salt_len
= salt_len
;
11258 return (PARSER_OK
);
11261 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11263 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11265 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11269 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11272 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11274 salt_t
*salt
= hash_buf
->salt
;
11276 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11277 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11278 digest
[2] = hex_to_uint (&input_buf
[16]);
11279 digest
[3] = hex_to_uint (&input_buf
[24]);
11281 digest
[0] = byte_swap_32 (digest
[0]);
11282 digest
[1] = byte_swap_32 (digest
[1]);
11283 digest
[2] = byte_swap_32 (digest
[2]);
11284 digest
[3] = byte_swap_32 (digest
[3]);
11286 digest
[0] -= MD4M_A
;
11287 digest
[1] -= MD4M_B
;
11288 digest
[2] -= MD4M_C
;
11289 digest
[3] -= MD4M_D
;
11291 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11293 uint salt_len
= input_len
- 32 - 1;
11295 char *salt_buf
= input_buf
+ 32 + 1;
11297 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11299 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11301 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11303 salt
->salt_len
= salt_len
;
11305 return (PARSER_OK
);
11308 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11310 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11312 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11316 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11319 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11321 salt_t
*salt
= hash_buf
->salt
;
11323 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11324 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11325 digest
[2] = hex_to_uint (&input_buf
[16]);
11326 digest
[3] = hex_to_uint (&input_buf
[24]);
11328 digest
[0] = byte_swap_32 (digest
[0]);
11329 digest
[1] = byte_swap_32 (digest
[1]);
11330 digest
[2] = byte_swap_32 (digest
[2]);
11331 digest
[3] = byte_swap_32 (digest
[3]);
11333 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11335 uint salt_len
= input_len
- 32 - 1;
11337 char *salt_buf
= input_buf
+ 32 + 1;
11339 uint salt_pc_block
[16];
11341 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11343 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11345 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11349 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11351 salt_pc_block
[14] = salt_len
* 8;
11353 uint salt_pc_digest
[4];
11355 salt_pc_digest
[0] = MAGIC_A
;
11356 salt_pc_digest
[1] = MAGIC_B
;
11357 salt_pc_digest
[2] = MAGIC_C
;
11358 salt_pc_digest
[3] = MAGIC_D
;
11360 md5_64 (salt_pc_block
, salt_pc_digest
);
11362 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11363 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11364 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11365 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11369 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11371 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11373 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11374 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11375 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11376 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11378 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11380 return (PARSER_OK
);
11383 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11385 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11387 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11389 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11390 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11391 digest
[2] = hex_to_uint (&input_buf
[16]);
11392 digest
[3] = hex_to_uint (&input_buf
[24]);
11393 digest
[4] = hex_to_uint (&input_buf
[32]);
11395 digest
[0] -= SHA1M_A
;
11396 digest
[1] -= SHA1M_B
;
11397 digest
[2] -= SHA1M_C
;
11398 digest
[3] -= SHA1M_D
;
11399 digest
[4] -= SHA1M_E
;
11401 return (PARSER_OK
);
11404 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11406 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11408 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11410 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11411 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11412 digest
[2] = hex_to_uint (&input_buf
[16]);
11413 digest
[3] = hex_to_uint (&input_buf
[24]);
11414 digest
[4] = hex_to_uint (&input_buf
[32]);
11416 return (PARSER_OK
);
11419 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11421 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11423 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11427 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11430 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11432 salt_t
*salt
= hash_buf
->salt
;
11434 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11435 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11436 digest
[2] = hex_to_uint (&input_buf
[16]);
11437 digest
[3] = hex_to_uint (&input_buf
[24]);
11438 digest
[4] = hex_to_uint (&input_buf
[32]);
11440 digest
[0] -= SHA1M_A
;
11441 digest
[1] -= SHA1M_B
;
11442 digest
[2] -= SHA1M_C
;
11443 digest
[3] -= SHA1M_D
;
11444 digest
[4] -= SHA1M_E
;
11446 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11448 uint salt_len
= input_len
- 40 - 1;
11450 char *salt_buf
= input_buf
+ 40 + 1;
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 return (PARSER_OK
);
11463 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11465 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11467 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11469 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11473 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11475 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11477 memcpy (digest
, tmp_buf
, 20);
11479 digest
[0] = byte_swap_32 (digest
[0]);
11480 digest
[1] = byte_swap_32 (digest
[1]);
11481 digest
[2] = byte_swap_32 (digest
[2]);
11482 digest
[3] = byte_swap_32 (digest
[3]);
11483 digest
[4] = byte_swap_32 (digest
[4]);
11485 digest
[0] -= SHA1M_A
;
11486 digest
[1] -= SHA1M_B
;
11487 digest
[2] -= SHA1M_C
;
11488 digest
[3] -= SHA1M_D
;
11489 digest
[4] -= SHA1M_E
;
11491 return (PARSER_OK
);
11494 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11496 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11498 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11500 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11502 salt_t
*salt
= hash_buf
->salt
;
11506 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11508 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11510 memcpy (digest
, tmp_buf
, 20);
11512 salt
->salt_len
= tmp_len
- 20;
11514 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11516 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11518 char *ptr
= (char *) salt
->salt_buf
;
11520 ptr
[salt
->salt_len
] = 0x80;
11523 digest
[0] = byte_swap_32 (digest
[0]);
11524 digest
[1] = byte_swap_32 (digest
[1]);
11525 digest
[2] = byte_swap_32 (digest
[2]);
11526 digest
[3] = byte_swap_32 (digest
[3]);
11527 digest
[4] = byte_swap_32 (digest
[4]);
11529 digest
[0] -= SHA1M_A
;
11530 digest
[1] -= SHA1M_B
;
11531 digest
[2] -= SHA1M_C
;
11532 digest
[3] -= SHA1M_D
;
11533 digest
[4] -= SHA1M_E
;
11535 return (PARSER_OK
);
11538 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11540 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11542 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11544 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11546 salt_t
*salt
= hash_buf
->salt
;
11548 char *salt_buf
= input_buf
+ 6;
11552 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11554 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11556 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11558 salt
->salt_len
= salt_len
;
11560 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11562 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11563 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11564 digest
[2] = hex_to_uint (&hash_pos
[16]);
11565 digest
[3] = hex_to_uint (&hash_pos
[24]);
11566 digest
[4] = hex_to_uint (&hash_pos
[32]);
11568 digest
[0] -= SHA1M_A
;
11569 digest
[1] -= SHA1M_B
;
11570 digest
[2] -= SHA1M_C
;
11571 digest
[3] -= SHA1M_D
;
11572 digest
[4] -= SHA1M_E
;
11574 return (PARSER_OK
);
11577 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11579 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11581 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11583 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11585 salt_t
*salt
= hash_buf
->salt
;
11587 char *salt_buf
= input_buf
+ 6;
11591 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11593 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11595 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11597 salt
->salt_len
= salt_len
;
11599 char *hash_pos
= input_buf
+ 6 + 8;
11601 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11602 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11603 digest
[2] = hex_to_uint (&hash_pos
[16]);
11604 digest
[3] = hex_to_uint (&hash_pos
[24]);
11605 digest
[4] = hex_to_uint (&hash_pos
[32]);
11607 digest
[0] -= SHA1M_A
;
11608 digest
[1] -= SHA1M_B
;
11609 digest
[2] -= SHA1M_C
;
11610 digest
[3] -= SHA1M_D
;
11611 digest
[4] -= SHA1M_E
;
11613 return (PARSER_OK
);
11616 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11618 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11620 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11622 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11624 salt_t
*salt
= hash_buf
->salt
;
11626 char *salt_buf
= input_buf
+ 6;
11630 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11632 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11634 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11636 salt
->salt_len
= salt_len
;
11638 char *hash_pos
= input_buf
+ 6 + 8;
11640 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11641 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11642 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11643 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11644 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11645 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11646 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11647 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11649 digest
[0] -= SHA512M_A
;
11650 digest
[1] -= SHA512M_B
;
11651 digest
[2] -= SHA512M_C
;
11652 digest
[3] -= SHA512M_D
;
11653 digest
[4] -= SHA512M_E
;
11654 digest
[5] -= SHA512M_F
;
11655 digest
[6] -= SHA512M_G
;
11656 digest
[7] -= SHA512M_H
;
11658 return (PARSER_OK
);
11661 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11663 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11665 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11669 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11672 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11674 salt_t
*salt
= hash_buf
->salt
;
11676 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11677 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11681 digest
[0] = byte_swap_32 (digest
[0]);
11682 digest
[1] = byte_swap_32 (digest
[1]);
11684 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11686 uint salt_len
= input_len
- 16 - 1;
11688 char *salt_buf
= input_buf
+ 16 + 1;
11690 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11692 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11694 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11696 salt
->salt_len
= salt_len
;
11698 return (PARSER_OK
);
11701 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11703 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11705 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11707 salt_t
*salt
= hash_buf
->salt
;
11709 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11710 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11711 digest
[2] = hex_to_uint (&input_buf
[16]);
11712 digest
[3] = hex_to_uint (&input_buf
[24]);
11713 digest
[4] = hex_to_uint (&input_buf
[32]);
11715 digest
[0] -= SHA1M_A
;
11716 digest
[1] -= SHA1M_B
;
11717 digest
[2] -= SHA1M_C
;
11718 digest
[3] -= SHA1M_D
;
11719 digest
[4] -= SHA1M_E
;
11721 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11723 uint salt_len
= input_len
- 40 - 1;
11725 char *salt_buf
= input_buf
+ 40 + 1;
11727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11729 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11731 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11733 salt
->salt_len
= salt_len
;
11735 return (PARSER_OK
);
11738 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11740 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11742 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11744 salt_t
*salt
= hash_buf
->salt
;
11746 char *hash_pos
= input_buf
;
11748 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11749 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11750 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11751 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11752 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11753 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11754 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11755 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11756 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11757 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11758 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11759 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11760 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11761 digest
[13] = hex_to_uint (&hash_pos
[104]);
11762 digest
[14] = hex_to_uint (&hash_pos
[112]);
11763 digest
[15] = hex_to_uint (&hash_pos
[120]);
11765 char *salt_pos
= input_buf
+ 128;
11767 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11768 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11769 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11770 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11772 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11773 salt
->salt_len
= 16;
11775 return (PARSER_OK
);
11778 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11780 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11782 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11784 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11785 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11786 digest
[2] = hex_to_uint (&input_buf
[16]);
11787 digest
[3] = hex_to_uint (&input_buf
[24]);
11788 digest
[4] = hex_to_uint (&input_buf
[32]);
11789 digest
[5] = hex_to_uint (&input_buf
[40]);
11790 digest
[6] = hex_to_uint (&input_buf
[48]);
11791 digest
[7] = hex_to_uint (&input_buf
[56]);
11793 digest
[0] -= SHA256M_A
;
11794 digest
[1] -= SHA256M_B
;
11795 digest
[2] -= SHA256M_C
;
11796 digest
[3] -= SHA256M_D
;
11797 digest
[4] -= SHA256M_E
;
11798 digest
[5] -= SHA256M_F
;
11799 digest
[6] -= SHA256M_G
;
11800 digest
[7] -= SHA256M_H
;
11802 return (PARSER_OK
);
11805 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11807 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11809 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11813 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11816 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11818 salt_t
*salt
= hash_buf
->salt
;
11820 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11821 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11822 digest
[2] = hex_to_uint (&input_buf
[16]);
11823 digest
[3] = hex_to_uint (&input_buf
[24]);
11824 digest
[4] = hex_to_uint (&input_buf
[32]);
11825 digest
[5] = hex_to_uint (&input_buf
[40]);
11826 digest
[6] = hex_to_uint (&input_buf
[48]);
11827 digest
[7] = hex_to_uint (&input_buf
[56]);
11829 digest
[0] -= SHA256M_A
;
11830 digest
[1] -= SHA256M_B
;
11831 digest
[2] -= SHA256M_C
;
11832 digest
[3] -= SHA256M_D
;
11833 digest
[4] -= SHA256M_E
;
11834 digest
[5] -= SHA256M_F
;
11835 digest
[6] -= SHA256M_G
;
11836 digest
[7] -= SHA256M_H
;
11838 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11840 uint salt_len
= input_len
- 64 - 1;
11842 char *salt_buf
= input_buf
+ 64 + 1;
11844 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11846 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11848 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11850 salt
->salt_len
= salt_len
;
11852 return (PARSER_OK
);
11855 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11857 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11859 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11861 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11862 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11863 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11864 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11865 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11866 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11870 digest
[0] -= SHA384M_A
;
11871 digest
[1] -= SHA384M_B
;
11872 digest
[2] -= SHA384M_C
;
11873 digest
[3] -= SHA384M_D
;
11874 digest
[4] -= SHA384M_E
;
11875 digest
[5] -= SHA384M_F
;
11879 return (PARSER_OK
);
11882 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11884 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11886 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11888 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11889 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11890 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11891 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11892 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11893 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11894 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11895 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11897 digest
[0] -= SHA512M_A
;
11898 digest
[1] -= SHA512M_B
;
11899 digest
[2] -= SHA512M_C
;
11900 digest
[3] -= SHA512M_D
;
11901 digest
[4] -= SHA512M_E
;
11902 digest
[5] -= SHA512M_F
;
11903 digest
[6] -= SHA512M_G
;
11904 digest
[7] -= SHA512M_H
;
11906 return (PARSER_OK
);
11909 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11911 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11913 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11917 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11920 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11922 salt_t
*salt
= hash_buf
->salt
;
11924 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11925 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11926 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11927 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11928 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11929 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11930 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11931 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11933 digest
[0] -= SHA512M_A
;
11934 digest
[1] -= SHA512M_B
;
11935 digest
[2] -= SHA512M_C
;
11936 digest
[3] -= SHA512M_D
;
11937 digest
[4] -= SHA512M_E
;
11938 digest
[5] -= SHA512M_F
;
11939 digest
[6] -= SHA512M_G
;
11940 digest
[7] -= SHA512M_H
;
11942 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11944 uint salt_len
= input_len
- 128 - 1;
11946 char *salt_buf
= input_buf
+ 128 + 1;
11948 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11950 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11952 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11954 salt
->salt_len
= salt_len
;
11956 return (PARSER_OK
);
11959 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11961 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11963 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11965 salt_t
*salt
= hash_buf
->salt
;
11967 char *salt_pos
= input_buf
+ 3;
11969 uint iterations_len
= 0;
11971 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11975 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11977 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11978 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11982 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11986 iterations_len
+= 8;
11990 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11993 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11995 char *hash_pos
= strchr (salt_pos
, '$');
11997 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11999 uint salt_len
= hash_pos
- salt_pos
;
12001 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12003 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12005 salt
->salt_len
= salt_len
;
12009 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12011 return (PARSER_OK
);
12014 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12016 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12018 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12020 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12022 salt_t
*salt
= hash_buf
->salt
;
12024 uint keccak_mdlen
= input_len
/ 2;
12026 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12028 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
12030 digest
[i
] = byte_swap_64 (digest
[i
]);
12033 salt
->keccak_mdlen
= keccak_mdlen
;
12035 return (PARSER_OK
);
12038 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12040 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12042 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12044 salt_t
*salt
= hash_buf
->salt
;
12046 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12049 * Parse that strange long line
12056 in_off
[0] = strtok (input_buf
, ":");
12058 in_len
[0] = strlen (in_off
[0]);
12062 for (i
= 1; i
< 9; i
++)
12064 in_off
[i
] = strtok (NULL
, ":");
12066 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12068 in_len
[i
] = strlen (in_off
[i
]);
12073 ptr
= (char *) ikepsk
->msg_buf
;
12075 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12076 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12077 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12078 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12079 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12080 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12084 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12086 ptr
= (char *) ikepsk
->nr_buf
;
12088 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12089 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12093 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12096 * Store to database
12101 digest
[0] = hex_to_uint (&ptr
[ 0]);
12102 digest
[1] = hex_to_uint (&ptr
[ 8]);
12103 digest
[2] = hex_to_uint (&ptr
[16]);
12104 digest
[3] = hex_to_uint (&ptr
[24]);
12106 digest
[0] = byte_swap_32 (digest
[0]);
12107 digest
[1] = byte_swap_32 (digest
[1]);
12108 digest
[2] = byte_swap_32 (digest
[2]);
12109 digest
[3] = byte_swap_32 (digest
[3]);
12111 salt
->salt_len
= 32;
12113 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12114 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12115 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12116 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12117 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12118 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12119 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12120 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12122 return (PARSER_OK
);
12125 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12127 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12129 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12131 salt_t
*salt
= hash_buf
->salt
;
12133 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12136 * Parse that strange long line
12143 in_off
[0] = strtok (input_buf
, ":");
12145 in_len
[0] = strlen (in_off
[0]);
12149 for (i
= 1; i
< 9; i
++)
12151 in_off
[i
] = strtok (NULL
, ":");
12153 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12155 in_len
[i
] = strlen (in_off
[i
]);
12160 ptr
= (char *) ikepsk
->msg_buf
;
12162 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12163 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12164 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12165 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12166 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12167 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12171 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12173 ptr
= (char *) ikepsk
->nr_buf
;
12175 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12176 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12180 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12183 * Store to database
12188 digest
[0] = hex_to_uint (&ptr
[ 0]);
12189 digest
[1] = hex_to_uint (&ptr
[ 8]);
12190 digest
[2] = hex_to_uint (&ptr
[16]);
12191 digest
[3] = hex_to_uint (&ptr
[24]);
12192 digest
[4] = hex_to_uint (&ptr
[32]);
12194 salt
->salt_len
= 32;
12196 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12197 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12198 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12199 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12200 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12201 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12202 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12203 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12205 return (PARSER_OK
);
12208 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12210 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12212 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12214 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12215 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12216 digest
[2] = hex_to_uint (&input_buf
[16]);
12217 digest
[3] = hex_to_uint (&input_buf
[24]);
12218 digest
[4] = hex_to_uint (&input_buf
[32]);
12220 digest
[0] = byte_swap_32 (digest
[0]);
12221 digest
[1] = byte_swap_32 (digest
[1]);
12222 digest
[2] = byte_swap_32 (digest
[2]);
12223 digest
[3] = byte_swap_32 (digest
[3]);
12224 digest
[4] = byte_swap_32 (digest
[4]);
12226 return (PARSER_OK
);
12229 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12231 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12233 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12235 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12236 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12237 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12238 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12239 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12240 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12241 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12242 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12243 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12244 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12245 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12246 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12247 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12248 digest
[13] = hex_to_uint (&input_buf
[104]);
12249 digest
[14] = hex_to_uint (&input_buf
[112]);
12250 digest
[15] = hex_to_uint (&input_buf
[120]);
12252 return (PARSER_OK
);
12255 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12257 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12259 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12261 salt_t
*salt
= hash_buf
->salt
;
12263 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12264 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12265 digest
[2] = hex_to_uint (&input_buf
[16]);
12266 digest
[3] = hex_to_uint (&input_buf
[24]);
12267 digest
[4] = hex_to_uint (&input_buf
[32]);
12269 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12271 uint salt_len
= input_len
- 40 - 1;
12273 char *salt_buf
= input_buf
+ 40 + 1;
12275 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12277 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12279 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12281 salt
->salt_len
= salt_len
;
12283 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12285 return (PARSER_OK
);
12288 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12290 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12292 salt_t
*salt
= hash_buf
->salt
;
12294 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12296 if (input_len
== 0)
12298 log_error ("TrueCrypt container not specified");
12303 FILE *fp
= fopen (input_buf
, "rb");
12307 log_error ("%s: %s", input_buf
, strerror (errno
));
12314 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12318 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12320 memcpy (tc
->salt_buf
, buf
, 64);
12322 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12324 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12326 salt
->salt_len
= 4;
12328 salt
->salt_iter
= 1000 - 1;
12330 digest
[0] = tc
->data_buf
[0];
12332 return (PARSER_OK
);
12335 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12337 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12339 salt_t
*salt
= hash_buf
->salt
;
12341 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12343 if (input_len
== 0)
12345 log_error ("TrueCrypt container not specified");
12350 FILE *fp
= fopen (input_buf
, "rb");
12354 log_error ("%s: %s", input_buf
, strerror (errno
));
12361 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12365 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12367 memcpy (tc
->salt_buf
, buf
, 64);
12369 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12371 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12373 salt
->salt_len
= 4;
12375 salt
->salt_iter
= 2000 - 1;
12377 digest
[0] = tc
->data_buf
[0];
12379 return (PARSER_OK
);
12382 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12384 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12386 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12388 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12390 salt_t
*salt
= hash_buf
->salt
;
12392 char *salt_pos
= input_buf
+ 6;
12394 char *hash_pos
= strchr (salt_pos
, '$');
12396 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12398 uint salt_len
= hash_pos
- salt_pos
;
12400 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12402 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12404 salt
->salt_len
= salt_len
;
12406 salt
->salt_iter
= 1000;
12410 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12412 return (PARSER_OK
);
12415 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12417 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12419 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12421 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12423 salt_t
*salt
= hash_buf
->salt
;
12425 char *iter_pos
= input_buf
+ 7;
12427 char *salt_pos
= strchr (iter_pos
, '$');
12429 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12433 char *hash_pos
= strchr (salt_pos
, '$');
12435 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12437 uint salt_len
= hash_pos
- salt_pos
;
12439 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12441 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12443 salt
->salt_len
= salt_len
;
12445 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12447 salt
->salt_sign
[0] = atoi (salt_iter
);
12449 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12453 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12455 digest
[0] = byte_swap_32 (digest
[0]);
12456 digest
[1] = byte_swap_32 (digest
[1]);
12457 digest
[2] = byte_swap_32 (digest
[2]);
12458 digest
[3] = byte_swap_32 (digest
[3]);
12459 digest
[4] = byte_swap_32 (digest
[4]);
12461 return (PARSER_OK
);
12464 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12466 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12468 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12470 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12472 salt_t
*salt
= hash_buf
->salt
;
12474 char *iter_pos
= input_buf
+ 9;
12476 char *salt_pos
= strchr (iter_pos
, '$');
12478 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12482 char *hash_pos
= strchr (salt_pos
, '$');
12484 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12486 uint salt_len
= hash_pos
- salt_pos
;
12488 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12490 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12492 salt
->salt_len
= salt_len
;
12494 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12496 salt
->salt_sign
[0] = atoi (salt_iter
);
12498 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12502 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12504 digest
[0] = byte_swap_32 (digest
[0]);
12505 digest
[1] = byte_swap_32 (digest
[1]);
12506 digest
[2] = byte_swap_32 (digest
[2]);
12507 digest
[3] = byte_swap_32 (digest
[3]);
12508 digest
[4] = byte_swap_32 (digest
[4]);
12509 digest
[5] = byte_swap_32 (digest
[5]);
12510 digest
[6] = byte_swap_32 (digest
[6]);
12511 digest
[7] = byte_swap_32 (digest
[7]);
12513 return (PARSER_OK
);
12516 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12518 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12520 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12522 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12524 salt_t
*salt
= hash_buf
->salt
;
12526 char *iter_pos
= input_buf
+ 9;
12528 char *salt_pos
= strchr (iter_pos
, '$');
12530 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12534 char *hash_pos
= strchr (salt_pos
, '$');
12536 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12538 uint salt_len
= hash_pos
- salt_pos
;
12540 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12542 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12544 salt
->salt_len
= salt_len
;
12546 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12548 salt
->salt_sign
[0] = atoi (salt_iter
);
12550 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12554 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12556 digest
[0] = byte_swap_64 (digest
[0]);
12557 digest
[1] = byte_swap_64 (digest
[1]);
12558 digest
[2] = byte_swap_64 (digest
[2]);
12559 digest
[3] = byte_swap_64 (digest
[3]);
12560 digest
[4] = byte_swap_64 (digest
[4]);
12561 digest
[5] = byte_swap_64 (digest
[5]);
12562 digest
[6] = byte_swap_64 (digest
[6]);
12563 digest
[7] = byte_swap_64 (digest
[7]);
12565 return (PARSER_OK
);
12568 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12570 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12572 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12574 salt_t
*salt
= hash_buf
->salt
;
12576 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12582 char *iterations_pos
= input_buf
;
12584 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12586 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12588 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12590 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12594 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12596 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12598 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12600 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12602 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12604 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12609 * pbkdf2 iterations
12612 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12615 * handle salt encoding
12618 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12620 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12622 const char p0
= saltbuf_pos
[i
+ 0];
12623 const char p1
= saltbuf_pos
[i
+ 1];
12625 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12626 | hex_convert (p0
) << 4;
12629 salt
->salt_len
= saltbuf_len
/ 2;
12632 * handle cipher encoding
12635 uint
*tmp
= (uint
*) mymalloc (32);
12637 char *cipherbuf_ptr
= (char *) tmp
;
12639 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12641 const char p0
= cipherbuf_pos
[i
+ 0];
12642 const char p1
= cipherbuf_pos
[i
+ 1];
12644 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12645 | hex_convert (p0
) << 4;
12648 // iv is stored at salt_buf 4 (length 16)
12649 // data is stored at salt_buf 8 (length 16)
12651 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12652 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12653 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12654 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12656 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12657 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12658 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12659 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12663 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12665 const char p0
= cipherbuf_pos
[j
+ 0];
12666 const char p1
= cipherbuf_pos
[j
+ 1];
12668 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12669 | hex_convert (p0
) << 4;
12676 digest
[0] = 0x10101010;
12677 digest
[1] = 0x10101010;
12678 digest
[2] = 0x10101010;
12679 digest
[3] = 0x10101010;
12681 return (PARSER_OK
);
12684 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12686 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12688 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12690 salt_t
*salt
= hash_buf
->salt
;
12692 char *hashbuf_pos
= input_buf
;
12694 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12696 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12698 uint hash_len
= iterations_pos
- hashbuf_pos
;
12700 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12704 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12706 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12708 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12712 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12714 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12716 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12718 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12720 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12722 salt
->salt_len
= salt_len
;
12724 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12726 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12727 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12728 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12729 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12731 return (PARSER_OK
);
12734 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12736 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12738 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12740 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12741 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12742 digest
[2] = hex_to_uint (&input_buf
[16]);
12743 digest
[3] = hex_to_uint (&input_buf
[24]);
12744 digest
[4] = hex_to_uint (&input_buf
[32]);
12745 digest
[5] = hex_to_uint (&input_buf
[40]);
12746 digest
[6] = hex_to_uint (&input_buf
[48]);
12747 digest
[7] = hex_to_uint (&input_buf
[56]);
12749 digest
[0] = byte_swap_32 (digest
[0]);
12750 digest
[1] = byte_swap_32 (digest
[1]);
12751 digest
[2] = byte_swap_32 (digest
[2]);
12752 digest
[3] = byte_swap_32 (digest
[3]);
12753 digest
[4] = byte_swap_32 (digest
[4]);
12754 digest
[5] = byte_swap_32 (digest
[5]);
12755 digest
[6] = byte_swap_32 (digest
[6]);
12756 digest
[7] = byte_swap_32 (digest
[7]);
12758 return (PARSER_OK
);
12761 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12763 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12765 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12767 salt_t
*salt
= hash_buf
->salt
;
12769 char *salt_pos
= input_buf
+ 3;
12771 uint iterations_len
= 0;
12773 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12777 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12779 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12780 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12784 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12788 iterations_len
+= 8;
12792 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12795 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12797 char *hash_pos
= strchr (salt_pos
, '$');
12799 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12801 uint salt_len
= hash_pos
- salt_pos
;
12803 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12805 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12807 salt
->salt_len
= salt_len
;
12811 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12813 return (PARSER_OK
);
12816 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12818 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12820 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12822 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12824 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12826 salt_t
*salt
= hash_buf
->salt
;
12828 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12830 char *iter_pos
= input_buf
+ 4;
12832 char *salt_pos
= strchr (iter_pos
, '$');
12834 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12838 char *hash_pos
= strchr (salt_pos
, '$');
12840 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12842 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12846 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12847 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12848 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12849 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12850 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12851 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12852 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12853 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12855 uint salt_len
= hash_pos
- salt_pos
- 1;
12857 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12859 salt
->salt_len
= salt_len
/ 2;
12861 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12862 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12863 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12864 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12865 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12866 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12867 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12868 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12870 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12871 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12872 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12873 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12874 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12875 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12876 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12877 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12878 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12879 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12881 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12883 salt
->salt_iter
= atoi (iter_pos
) - 1;
12885 return (PARSER_OK
);
12888 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12890 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12892 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12894 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12896 salt_t
*salt
= hash_buf
->salt
;
12898 char *salt_pos
= input_buf
+ 14;
12900 char *hash_pos
= strchr (salt_pos
, '*');
12902 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12906 uint salt_len
= hash_pos
- salt_pos
- 1;
12908 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12914 salt
->salt_len
= salt_len
;
12916 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12918 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12920 memcpy (digest
, tmp_buf
, 32);
12922 digest
[0] = byte_swap_32 (digest
[0]);
12923 digest
[1] = byte_swap_32 (digest
[1]);
12924 digest
[2] = byte_swap_32 (digest
[2]);
12925 digest
[3] = byte_swap_32 (digest
[3]);
12926 digest
[4] = byte_swap_32 (digest
[4]);
12927 digest
[5] = byte_swap_32 (digest
[5]);
12928 digest
[6] = byte_swap_32 (digest
[6]);
12929 digest
[7] = byte_swap_32 (digest
[7]);
12931 digest
[0] -= SHA256M_A
;
12932 digest
[1] -= SHA256M_B
;
12933 digest
[2] -= SHA256M_C
;
12934 digest
[3] -= SHA256M_D
;
12935 digest
[4] -= SHA256M_E
;
12936 digest
[5] -= SHA256M_F
;
12937 digest
[6] -= SHA256M_G
;
12938 digest
[7] -= SHA256M_H
;
12940 return (PARSER_OK
);
12943 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12945 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12947 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12949 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12951 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12953 salt_t
*salt
= hash_buf
->salt
;
12955 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12957 char *iter_pos
= input_buf
+ 19;
12959 char *salt_pos
= strchr (iter_pos
, '.');
12961 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12965 char *hash_pos
= strchr (salt_pos
, '.');
12967 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12969 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12973 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12974 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12975 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12976 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12977 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12978 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12979 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12980 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12982 uint salt_len
= hash_pos
- salt_pos
- 1;
12986 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12990 for (i
= 0; i
< salt_len
; i
++)
12992 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12995 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12996 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12998 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13000 salt
->salt_len
= salt_len
;
13002 salt
->salt_iter
= atoi (iter_pos
) - 1;
13004 return (PARSER_OK
);
13007 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13009 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13011 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13013 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13015 salt_t
*salt
= hash_buf
->salt
;
13019 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13021 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
13023 memcpy (digest
, tmp_buf
, 64);
13025 digest
[0] = byte_swap_64 (digest
[0]);
13026 digest
[1] = byte_swap_64 (digest
[1]);
13027 digest
[2] = byte_swap_64 (digest
[2]);
13028 digest
[3] = byte_swap_64 (digest
[3]);
13029 digest
[4] = byte_swap_64 (digest
[4]);
13030 digest
[5] = byte_swap_64 (digest
[5]);
13031 digest
[6] = byte_swap_64 (digest
[6]);
13032 digest
[7] = byte_swap_64 (digest
[7]);
13034 digest
[0] -= SHA512M_A
;
13035 digest
[1] -= SHA512M_B
;
13036 digest
[2] -= SHA512M_C
;
13037 digest
[3] -= SHA512M_D
;
13038 digest
[4] -= SHA512M_E
;
13039 digest
[5] -= SHA512M_F
;
13040 digest
[6] -= SHA512M_G
;
13041 digest
[7] -= SHA512M_H
;
13043 salt
->salt_len
= tmp_len
- 64;
13045 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13047 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13049 char *ptr
= (char *) salt
->salt_buf
;
13051 ptr
[salt
->salt_len
] = 0x80;
13054 return (PARSER_OK
);
13057 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13059 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13061 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13065 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13068 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13070 salt_t
*salt
= hash_buf
->salt
;
13072 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13073 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13074 digest
[2] = hex_to_uint (&input_buf
[16]);
13075 digest
[3] = hex_to_uint (&input_buf
[24]);
13077 digest
[0] = byte_swap_32 (digest
[0]);
13078 digest
[1] = byte_swap_32 (digest
[1]);
13079 digest
[2] = byte_swap_32 (digest
[2]);
13080 digest
[3] = byte_swap_32 (digest
[3]);
13082 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13084 uint salt_len
= input_len
- 32 - 1;
13086 char *salt_buf
= input_buf
+ 32 + 1;
13088 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13090 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13092 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13094 salt
->salt_len
= salt_len
;
13096 return (PARSER_OK
);
13099 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13101 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13103 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13107 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13110 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13112 salt_t
*salt
= hash_buf
->salt
;
13114 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13115 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13116 digest
[2] = hex_to_uint (&input_buf
[16]);
13117 digest
[3] = hex_to_uint (&input_buf
[24]);
13118 digest
[4] = hex_to_uint (&input_buf
[32]);
13120 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13122 uint salt_len
= input_len
- 40 - 1;
13124 char *salt_buf
= input_buf
+ 40 + 1;
13126 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13128 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13132 salt
->salt_len
= salt_len
;
13134 return (PARSER_OK
);
13137 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13139 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13141 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13145 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13148 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13150 salt_t
*salt
= hash_buf
->salt
;
13152 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13153 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13154 digest
[2] = hex_to_uint (&input_buf
[16]);
13155 digest
[3] = hex_to_uint (&input_buf
[24]);
13156 digest
[4] = hex_to_uint (&input_buf
[32]);
13157 digest
[5] = hex_to_uint (&input_buf
[40]);
13158 digest
[6] = hex_to_uint (&input_buf
[48]);
13159 digest
[7] = hex_to_uint (&input_buf
[56]);
13161 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13163 uint salt_len
= input_len
- 64 - 1;
13165 char *salt_buf
= input_buf
+ 64 + 1;
13167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13169 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13171 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13173 salt
->salt_len
= salt_len
;
13175 return (PARSER_OK
);
13178 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13180 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13182 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13186 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13189 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13191 salt_t
*salt
= hash_buf
->salt
;
13193 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13194 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13195 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13196 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13197 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13198 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13199 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13200 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13202 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13204 uint salt_len
= input_len
- 128 - 1;
13206 char *salt_buf
= input_buf
+ 128 + 1;
13208 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13210 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13212 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13214 salt
->salt_len
= salt_len
;
13216 return (PARSER_OK
);
13219 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13221 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13223 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13225 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13227 salt_t
*salt
= hash_buf
->salt
;
13229 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13235 char *user_pos
= input_buf
+ 10 + 1;
13237 char *realm_pos
= strchr (user_pos
, '$');
13239 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13241 uint user_len
= realm_pos
- user_pos
;
13243 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13247 char *salt_pos
= strchr (realm_pos
, '$');
13249 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13251 uint realm_len
= salt_pos
- realm_pos
;
13253 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13257 char *data_pos
= strchr (salt_pos
, '$');
13259 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13261 uint salt_len
= data_pos
- salt_pos
;
13263 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13267 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13269 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13275 memcpy (krb5pa
->user
, user_pos
, user_len
);
13276 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13277 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13279 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13281 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13283 const char p0
= data_pos
[i
+ 0];
13284 const char p1
= data_pos
[i
+ 1];
13286 *timestamp_ptr
++ = hex_convert (p1
) << 0
13287 | hex_convert (p0
) << 4;
13290 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13292 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13294 const char p0
= data_pos
[i
+ 0];
13295 const char p1
= data_pos
[i
+ 1];
13297 *checksum_ptr
++ = hex_convert (p1
) << 0
13298 | hex_convert (p0
) << 4;
13302 * copy some data to generic buffers to make sorting happy
13305 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13306 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13307 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13308 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13309 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13310 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13311 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13312 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13313 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13315 salt
->salt_len
= 36;
13317 digest
[0] = krb5pa
->checksum
[0];
13318 digest
[1] = krb5pa
->checksum
[1];
13319 digest
[2] = krb5pa
->checksum
[2];
13320 digest
[3] = krb5pa
->checksum
[3];
13322 return (PARSER_OK
);
13325 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13327 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13329 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13331 salt_t
*salt
= hash_buf
->salt
;
13337 char *salt_pos
= input_buf
;
13339 char *hash_pos
= strchr (salt_pos
, '$');
13341 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13343 uint salt_len
= hash_pos
- salt_pos
;
13345 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13349 uint hash_len
= input_len
- 1 - salt_len
;
13351 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13359 for (uint i
= 0; i
< salt_len
; i
++)
13361 if (salt_pos
[i
] == ' ') continue;
13366 // SAP user names cannot be longer than 12 characters
13367 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13369 // SAP user name cannot start with ! or ?
13370 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13378 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13380 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13382 salt
->salt_len
= salt_len
;
13384 digest
[0] = hex_to_uint (&hash_pos
[0]);
13385 digest
[1] = hex_to_uint (&hash_pos
[8]);
13389 digest
[0] = byte_swap_32 (digest
[0]);
13390 digest
[1] = byte_swap_32 (digest
[1]);
13392 return (PARSER_OK
);
13395 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13397 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13399 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13401 salt_t
*salt
= hash_buf
->salt
;
13407 char *salt_pos
= input_buf
;
13409 char *hash_pos
= strchr (salt_pos
, '$');
13411 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13413 uint salt_len
= hash_pos
- salt_pos
;
13415 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13419 uint hash_len
= input_len
- 1 - salt_len
;
13421 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13429 for (uint i
= 0; i
< salt_len
; i
++)
13431 if (salt_pos
[i
] == ' ') continue;
13436 // SAP user names cannot be longer than 12 characters
13437 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13438 // so far nobody complained so we stay with this because it helps in optimization
13439 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13441 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13443 // SAP user name cannot start with ! or ?
13444 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13450 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13452 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13454 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13456 salt
->salt_len
= salt_len
;
13458 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13459 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13460 digest
[2] = hex_to_uint (&hash_pos
[16]);
13461 digest
[3] = hex_to_uint (&hash_pos
[24]);
13462 digest
[4] = hex_to_uint (&hash_pos
[32]);
13464 return (PARSER_OK
);
13467 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13469 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13471 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13473 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13475 salt_t
*salt
= hash_buf
->salt
;
13477 char *iter_pos
= input_buf
+ 3;
13479 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13481 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13483 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13485 salt
->salt_iter
= salt_iter
;
13487 char *salt_pos
= iter_pos
+ 1;
13491 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13493 salt
->salt_len
= salt_len
;
13495 char *hash_pos
= salt_pos
+ salt_len
;
13497 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13501 char *tmp
= (char *) salt
->salt_buf_pc
;
13503 tmp
[0] = hash_pos
[42];
13507 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13508 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13509 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13510 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13516 return (PARSER_OK
);
13519 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13521 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13523 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13525 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13527 salt_t
*salt
= hash_buf
->salt
;
13529 char *salt_buf
= input_buf
+ 6;
13531 uint salt_len
= 16;
13533 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13535 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13537 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13539 salt
->salt_len
= salt_len
;
13541 char *hash_pos
= input_buf
+ 6 + 16;
13543 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13544 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13545 digest
[2] = hex_to_uint (&hash_pos
[16]);
13546 digest
[3] = hex_to_uint (&hash_pos
[24]);
13547 digest
[4] = hex_to_uint (&hash_pos
[32]);
13548 digest
[5] = hex_to_uint (&hash_pos
[40]);
13549 digest
[6] = hex_to_uint (&hash_pos
[48]);
13550 digest
[7] = hex_to_uint (&hash_pos
[56]);
13552 return (PARSER_OK
);
13555 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13557 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13559 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13561 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13562 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13566 return (PARSER_OK
);
13569 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13571 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13573 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13575 salt_t
*salt
= hash_buf
->salt
;
13577 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13579 char *saltbuf_pos
= input_buf
;
13581 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13583 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13585 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13587 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13588 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13590 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13594 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13596 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13598 char *salt_ptr
= (char *) saltbuf_pos
;
13599 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13604 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13606 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13609 rakp_ptr
[j
] = 0x80;
13611 rakp
->salt_len
= j
;
13613 for (i
= 0; i
< 64; i
++)
13615 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13618 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13619 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13620 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13621 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13622 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13623 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13624 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13625 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13627 salt
->salt_len
= 32; // muss min. 32 haben
13629 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13630 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13631 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13632 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13633 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13635 return (PARSER_OK
);
13638 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13640 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13642 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13644 salt_t
*salt
= hash_buf
->salt
;
13646 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13648 char *salt_pos
= input_buf
+ 1;
13650 memcpy (salt
->salt_buf
, salt_pos
, 8);
13652 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13653 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13655 salt
->salt_len
= 8;
13657 char *hash_pos
= salt_pos
+ 8;
13659 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13660 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13661 digest
[2] = hex_to_uint (&hash_pos
[16]);
13662 digest
[3] = hex_to_uint (&hash_pos
[24]);
13663 digest
[4] = hex_to_uint (&hash_pos
[32]);
13665 digest
[0] -= SHA1M_A
;
13666 digest
[1] -= SHA1M_B
;
13667 digest
[2] -= SHA1M_C
;
13668 digest
[3] -= SHA1M_D
;
13669 digest
[4] -= SHA1M_E
;
13671 return (PARSER_OK
);
13674 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13676 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13678 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13680 salt_t
*salt
= hash_buf
->salt
;
13682 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13683 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13684 digest
[2] = hex_to_uint (&input_buf
[16]);
13685 digest
[3] = hex_to_uint (&input_buf
[24]);
13687 digest
[0] = byte_swap_32 (digest
[0]);
13688 digest
[1] = byte_swap_32 (digest
[1]);
13689 digest
[2] = byte_swap_32 (digest
[2]);
13690 digest
[3] = byte_swap_32 (digest
[3]);
13692 digest
[0] -= MD5M_A
;
13693 digest
[1] -= MD5M_B
;
13694 digest
[2] -= MD5M_C
;
13695 digest
[3] -= MD5M_D
;
13697 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13699 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13701 uint32_t *salt_buf
= salt
->salt_buf
;
13703 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13704 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13705 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13706 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13708 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13709 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13710 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13711 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13713 salt
->salt_len
= 16 + 1;
13715 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13717 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13719 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13721 return (PARSER_OK
);
13724 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13726 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13728 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13730 salt_t
*salt
= hash_buf
->salt
;
13732 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13738 char *hashbuf_pos
= input_buf
;
13740 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13742 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13744 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13746 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13750 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13752 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13754 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13756 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13760 char *databuf_pos
= strchr (iteration_pos
, ':');
13762 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13764 const uint iteration_len
= databuf_pos
- iteration_pos
;
13766 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13767 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13769 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13771 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13772 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13778 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13779 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13780 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13781 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13782 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13783 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13784 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13785 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13789 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13791 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13793 const char p0
= saltbuf_pos
[i
+ 0];
13794 const char p1
= saltbuf_pos
[i
+ 1];
13796 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13797 | hex_convert (p0
) << 4;
13800 salt
->salt_buf
[4] = 0x01000000;
13801 salt
->salt_buf
[5] = 0x80;
13803 salt
->salt_len
= saltbuf_len
/ 2;
13807 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13811 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13813 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13815 const char p0
= databuf_pos
[i
+ 0];
13816 const char p1
= databuf_pos
[i
+ 1];
13818 *databuf_ptr
++ = hex_convert (p1
) << 0
13819 | hex_convert (p0
) << 4;
13822 *databuf_ptr
++ = 0x80;
13824 for (uint i
= 0; i
< 512; i
++)
13826 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13829 cloudkey
->data_len
= databuf_len
/ 2;
13831 return (PARSER_OK
);
13834 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13836 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13838 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13840 salt_t
*salt
= hash_buf
->salt
;
13846 char *hashbuf_pos
= input_buf
;
13848 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13850 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13852 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13854 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13858 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13860 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13862 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13864 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13866 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13870 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13872 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13874 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13876 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13878 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13882 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13884 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13885 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13887 // ok, the plan for this algorithm is the following:
13888 // we have 2 salts here, the domain-name and a random salt
13889 // while both are used in the initial transformation,
13890 // only the random salt is used in the following iterations
13891 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13892 // and one that includes only the real salt (stored into salt_buf[]).
13893 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13895 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13897 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13899 memcpy (digest
, tmp_buf
, 20);
13901 digest
[0] = byte_swap_32 (digest
[0]);
13902 digest
[1] = byte_swap_32 (digest
[1]);
13903 digest
[2] = byte_swap_32 (digest
[2]);
13904 digest
[3] = byte_swap_32 (digest
[3]);
13905 digest
[4] = byte_swap_32 (digest
[4]);
13909 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13911 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13913 char *len_ptr
= NULL
;
13915 for (uint i
= 0; i
< domainbuf_len
; i
++)
13917 if (salt_buf_pc_ptr
[i
] == '.')
13919 len_ptr
= &salt_buf_pc_ptr
[i
];
13929 salt
->salt_buf_pc
[7] = domainbuf_len
;
13933 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13935 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13937 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13939 salt
->salt_len
= salt_len
;
13943 salt
->salt_iter
= atoi (iteration_pos
);
13945 return (PARSER_OK
);
13948 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13950 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13952 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13954 salt_t
*salt
= hash_buf
->salt
;
13956 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13957 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13958 digest
[2] = hex_to_uint (&input_buf
[16]);
13959 digest
[3] = hex_to_uint (&input_buf
[24]);
13960 digest
[4] = hex_to_uint (&input_buf
[32]);
13962 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13964 uint salt_len
= input_len
- 40 - 1;
13966 char *salt_buf
= input_buf
+ 40 + 1;
13968 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13970 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13972 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13974 salt
->salt_len
= salt_len
;
13976 return (PARSER_OK
);
13979 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13981 const uint8_t ascii_to_ebcdic
[] =
13983 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13984 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13985 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13986 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13987 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13988 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13989 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13990 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13991 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13992 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13993 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13994 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13995 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13996 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13997 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13998 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14001 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14003 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14005 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14007 salt_t
*salt
= hash_buf
->salt
;
14009 char *salt_pos
= input_buf
+ 6 + 1;
14011 char *digest_pos
= strchr (salt_pos
, '*');
14013 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14015 uint salt_len
= digest_pos
- salt_pos
;
14017 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14019 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14021 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14025 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14026 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14028 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14030 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14032 salt
->salt_len
= salt_len
;
14034 for (uint i
= 0; i
< salt_len
; i
++)
14036 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14038 for (uint i
= salt_len
; i
< 8; i
++)
14040 salt_buf_pc_ptr
[i
] = 0x40;
14045 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14047 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
14048 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
14050 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
14051 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
14053 digest
[0] = byte_swap_32 (digest
[0]);
14054 digest
[1] = byte_swap_32 (digest
[1]);
14056 IP (digest
[0], digest
[1], tt
);
14058 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
14059 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
14063 return (PARSER_OK
);
14066 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14068 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14070 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14072 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14073 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14074 digest
[2] = hex_to_uint (&input_buf
[16]);
14075 digest
[3] = hex_to_uint (&input_buf
[24]);
14077 digest
[0] = byte_swap_32 (digest
[0]);
14078 digest
[1] = byte_swap_32 (digest
[1]);
14079 digest
[2] = byte_swap_32 (digest
[2]);
14080 digest
[3] = byte_swap_32 (digest
[3]);
14082 return (PARSER_OK
);
14085 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14087 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14089 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14091 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14093 salt_t
*salt
= hash_buf
->salt
;
14097 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14099 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14101 tmp_buf
[3] += -4; // dont ask!
14103 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14105 salt
->salt_len
= 5;
14107 memcpy (digest
, tmp_buf
+ 5, 9);
14109 // yes, only 9 byte are needed to crack, but 10 to display
14111 salt
->salt_buf_pc
[7] = input_buf
[20];
14113 return (PARSER_OK
);
14116 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14118 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14120 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14122 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14124 salt_t
*salt
= hash_buf
->salt
;
14128 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14130 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14132 tmp_buf
[3] += -4; // dont ask!
14136 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14138 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)
14142 char tmp_iter_buf
[11];
14144 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14146 tmp_iter_buf
[10] = 0;
14148 salt
->salt_iter
= atoi (tmp_iter_buf
);
14150 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14152 return (PARSER_SALT_ITERATION
);
14155 salt
->salt_iter
--; // first round in init
14157 // 2 additional bytes for display only
14159 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14160 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14164 memcpy (digest
, tmp_buf
+ 28, 8);
14166 digest
[0] = byte_swap_32 (digest
[0]);
14167 digest
[1] = byte_swap_32 (digest
[1]);
14171 return (PARSER_OK
);
14174 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14176 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14178 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14180 salt_t
*salt
= hash_buf
->salt
;
14182 char *salt_buf_pos
= input_buf
;
14184 char *hash_buf_pos
= salt_buf_pos
+ 6;
14186 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14187 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14188 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14189 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14190 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14191 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14192 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14193 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14195 digest
[0] -= SHA256M_A
;
14196 digest
[1] -= SHA256M_B
;
14197 digest
[2] -= SHA256M_C
;
14198 digest
[3] -= SHA256M_D
;
14199 digest
[4] -= SHA256M_E
;
14200 digest
[5] -= SHA256M_F
;
14201 digest
[6] -= SHA256M_G
;
14202 digest
[7] -= SHA256M_H
;
14204 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14206 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14208 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14210 salt
->salt_len
= salt_len
;
14212 return (PARSER_OK
);
14215 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14217 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14219 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14221 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14223 salt_t
*salt
= hash_buf
->salt
;
14225 char *salt_buf
= input_buf
+ 6;
14227 char *digest_buf
= strchr (salt_buf
, '$');
14229 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14231 uint salt_len
= digest_buf
- salt_buf
;
14233 digest_buf
++; // skip the '$' symbol
14235 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14237 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14239 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14241 salt
->salt_len
= salt_len
;
14243 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14244 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14245 digest
[2] = hex_to_uint (&digest_buf
[16]);
14246 digest
[3] = hex_to_uint (&digest_buf
[24]);
14248 digest
[0] = byte_swap_32 (digest
[0]);
14249 digest
[1] = byte_swap_32 (digest
[1]);
14250 digest
[2] = byte_swap_32 (digest
[2]);
14251 digest
[3] = byte_swap_32 (digest
[3]);
14253 digest
[0] -= MD5M_A
;
14254 digest
[1] -= MD5M_B
;
14255 digest
[2] -= MD5M_C
;
14256 digest
[3] -= MD5M_D
;
14258 return (PARSER_OK
);
14261 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14263 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14265 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14267 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14269 salt_t
*salt
= hash_buf
->salt
;
14271 char *salt_buf
= input_buf
+ 3;
14273 char *digest_buf
= strchr (salt_buf
, '$');
14275 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14277 uint salt_len
= digest_buf
- salt_buf
;
14279 digest_buf
++; // skip the '$' symbol
14281 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14283 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14285 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14287 salt_buf_ptr
[salt_len
] = 0x2d;
14289 salt
->salt_len
= salt_len
+ 1;
14291 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14292 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14293 digest
[2] = hex_to_uint (&digest_buf
[16]);
14294 digest
[3] = hex_to_uint (&digest_buf
[24]);
14296 digest
[0] = byte_swap_32 (digest
[0]);
14297 digest
[1] = byte_swap_32 (digest
[1]);
14298 digest
[2] = byte_swap_32 (digest
[2]);
14299 digest
[3] = byte_swap_32 (digest
[3]);
14301 digest
[0] -= MD5M_A
;
14302 digest
[1] -= MD5M_B
;
14303 digest
[2] -= MD5M_C
;
14304 digest
[3] -= MD5M_D
;
14306 return (PARSER_OK
);
14309 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14311 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14313 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14317 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14319 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14321 memcpy (digest
, tmp_buf
, 20);
14323 digest
[0] = byte_swap_32 (digest
[0]);
14324 digest
[1] = byte_swap_32 (digest
[1]);
14325 digest
[2] = byte_swap_32 (digest
[2]);
14326 digest
[3] = byte_swap_32 (digest
[3]);
14327 digest
[4] = byte_swap_32 (digest
[4]);
14329 digest
[0] -= SHA1M_A
;
14330 digest
[1] -= SHA1M_B
;
14331 digest
[2] -= SHA1M_C
;
14332 digest
[3] -= SHA1M_D
;
14333 digest
[4] -= SHA1M_E
;
14335 return (PARSER_OK
);
14338 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14340 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14342 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14344 salt_t
*salt
= hash_buf
->salt
;
14346 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14347 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14348 digest
[2] = hex_to_uint (&input_buf
[16]);
14349 digest
[3] = hex_to_uint (&input_buf
[24]);
14351 digest
[0] = byte_swap_32 (digest
[0]);
14352 digest
[1] = byte_swap_32 (digest
[1]);
14353 digest
[2] = byte_swap_32 (digest
[2]);
14354 digest
[3] = byte_swap_32 (digest
[3]);
14356 digest
[0] -= MD5M_A
;
14357 digest
[1] -= MD5M_B
;
14358 digest
[2] -= MD5M_C
;
14359 digest
[3] -= MD5M_D
;
14361 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14363 uint salt_len
= input_len
- 32 - 1;
14365 char *salt_buf
= input_buf
+ 32 + 1;
14367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14369 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14371 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14374 * add static "salt" part
14377 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14381 salt
->salt_len
= salt_len
;
14383 return (PARSER_OK
);
14386 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14388 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14390 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14392 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14394 salt_t
*salt
= hash_buf
->salt
;
14396 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14402 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14404 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14406 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14408 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14410 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14414 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14416 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14418 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14420 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14424 char *keybuf_pos
= strchr (keylen_pos
, '$');
14426 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14428 uint keylen_len
= keybuf_pos
- keylen_pos
;
14430 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14434 char *databuf_pos
= strchr (keybuf_pos
, '$');
14436 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14438 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14440 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14444 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14446 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14452 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14453 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14454 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14455 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14457 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14458 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14459 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14460 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14462 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14463 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14464 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14465 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14467 salt
->salt_len
= 16;
14468 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14470 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14472 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14475 return (PARSER_OK
);
14478 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14480 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14482 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14484 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14486 salt_t
*salt
= hash_buf
->salt
;
14492 // first is the N salt parameter
14494 char *N_pos
= input_buf
+ 6;
14496 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14500 salt
->scrypt_N
= atoi (N_pos
);
14504 char *r_pos
= strchr (N_pos
, ':');
14506 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14510 salt
->scrypt_r
= atoi (r_pos
);
14514 char *p_pos
= strchr (r_pos
, ':');
14516 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14520 salt
->scrypt_p
= atoi (p_pos
);
14524 char *saltbuf_pos
= strchr (p_pos
, ':');
14526 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14530 char *hash_pos
= strchr (saltbuf_pos
, ':');
14532 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14540 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14542 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14546 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14548 salt
->salt_len
= tmp_len
;
14549 salt
->salt_iter
= 1;
14551 // digest - base64 decode
14553 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14555 tmp_len
= input_len
- (hash_pos
- input_buf
);
14557 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14559 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14561 memcpy (digest
, tmp_buf
, 32);
14563 return (PARSER_OK
);
14566 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14568 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14570 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14572 salt_t
*salt
= hash_buf
->salt
;
14578 char decrypted
[76]; // iv + hash
14580 juniper_decrypt_hash (input_buf
, decrypted
);
14582 char *md5crypt_hash
= decrypted
+ 12;
14584 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14586 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14588 char *salt_pos
= md5crypt_hash
+ 3;
14590 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14592 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14594 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14598 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14600 return (PARSER_OK
);
14603 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14605 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14607 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14609 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14611 salt_t
*salt
= hash_buf
->salt
;
14613 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14619 // first is *raw* salt
14621 char *salt_pos
= input_buf
+ 3;
14623 char *hash_pos
= strchr (salt_pos
, '$');
14625 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14627 uint salt_len
= hash_pos
- salt_pos
;
14629 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14633 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14635 memcpy (salt_buf_ptr
, salt_pos
, 14);
14637 salt_buf_ptr
[17] = 0x01;
14638 salt_buf_ptr
[18] = 0x80;
14640 // add some stuff to normal salt to make sorted happy
14642 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14643 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14644 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14645 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14647 salt
->salt_len
= salt_len
;
14648 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14650 // base64 decode hash
14654 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14656 uint hash_len
= input_len
- 3 - salt_len
- 1;
14658 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14660 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14662 memcpy (digest
, tmp_buf
, 32);
14664 digest
[0] = byte_swap_32 (digest
[0]);
14665 digest
[1] = byte_swap_32 (digest
[1]);
14666 digest
[2] = byte_swap_32 (digest
[2]);
14667 digest
[3] = byte_swap_32 (digest
[3]);
14668 digest
[4] = byte_swap_32 (digest
[4]);
14669 digest
[5] = byte_swap_32 (digest
[5]);
14670 digest
[6] = byte_swap_32 (digest
[6]);
14671 digest
[7] = byte_swap_32 (digest
[7]);
14673 return (PARSER_OK
);
14676 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14678 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14680 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14682 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14684 salt_t
*salt
= hash_buf
->salt
;
14690 // first is *raw* salt
14692 char *salt_pos
= input_buf
+ 3;
14694 char *hash_pos
= strchr (salt_pos
, '$');
14696 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14698 uint salt_len
= hash_pos
- salt_pos
;
14700 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14702 salt
->salt_len
= salt_len
;
14705 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14707 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14708 salt_buf_ptr
[salt_len
] = 0;
14710 // base64 decode hash
14714 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14716 uint hash_len
= input_len
- 3 - salt_len
- 1;
14718 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14720 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14722 memcpy (digest
, tmp_buf
, 32);
14725 salt
->scrypt_N
= 16384;
14726 salt
->scrypt_r
= 1;
14727 salt
->scrypt_p
= 1;
14728 salt
->salt_iter
= 1;
14730 return (PARSER_OK
);
14733 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14735 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14737 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14739 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14741 salt_t
*salt
= hash_buf
->salt
;
14743 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14749 char *version_pos
= input_buf
+ 8 + 1;
14751 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14753 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14755 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14757 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14759 verifierHashSize_pos
++;
14761 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14763 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14765 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14767 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14771 char *saltSize_pos
= strchr (keySize_pos
, '*');
14773 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14775 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14777 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14781 char *osalt_pos
= strchr (saltSize_pos
, '*');
14783 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14785 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14787 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14791 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14793 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14795 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14797 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14799 encryptedVerifier_pos
++;
14801 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14803 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14805 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14807 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14809 encryptedVerifierHash_pos
++;
14811 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;
14813 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14815 const uint version
= atoi (version_pos
);
14817 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14819 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14821 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14823 const uint keySize
= atoi (keySize_pos
);
14825 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14827 office2007
->keySize
= keySize
;
14829 const uint saltSize
= atoi (saltSize_pos
);
14831 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14837 salt
->salt_len
= 16;
14838 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14840 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14841 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14842 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14843 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14849 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14850 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14851 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14852 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14854 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14855 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14856 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14857 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14858 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14864 digest
[0] = office2007
->encryptedVerifierHash
[0];
14865 digest
[1] = office2007
->encryptedVerifierHash
[1];
14866 digest
[2] = office2007
->encryptedVerifierHash
[2];
14867 digest
[3] = office2007
->encryptedVerifierHash
[3];
14869 return (PARSER_OK
);
14872 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14874 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14876 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14878 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14880 salt_t
*salt
= hash_buf
->salt
;
14882 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14888 char *version_pos
= input_buf
+ 8 + 1;
14890 char *spinCount_pos
= strchr (version_pos
, '*');
14892 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14894 uint32_t version_len
= spinCount_pos
- version_pos
;
14896 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14900 char *keySize_pos
= strchr (spinCount_pos
, '*');
14902 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14904 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14906 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14910 char *saltSize_pos
= strchr (keySize_pos
, '*');
14912 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14914 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14916 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14920 char *osalt_pos
= strchr (saltSize_pos
, '*');
14922 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14924 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14926 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14930 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14932 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14934 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14936 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14938 encryptedVerifier_pos
++;
14940 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14942 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14944 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14946 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14948 encryptedVerifierHash_pos
++;
14950 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;
14952 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14954 const uint version
= atoi (version_pos
);
14956 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14958 const uint spinCount
= atoi (spinCount_pos
);
14960 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14962 const uint keySize
= atoi (keySize_pos
);
14964 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14966 const uint saltSize
= atoi (saltSize_pos
);
14968 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14974 salt
->salt_len
= 16;
14975 salt
->salt_iter
= spinCount
;
14977 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14978 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14979 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14980 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14986 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14987 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14988 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14989 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14991 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14992 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14993 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14994 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14995 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14996 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14997 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14998 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15004 digest
[0] = office2010
->encryptedVerifierHash
[0];
15005 digest
[1] = office2010
->encryptedVerifierHash
[1];
15006 digest
[2] = office2010
->encryptedVerifierHash
[2];
15007 digest
[3] = office2010
->encryptedVerifierHash
[3];
15009 return (PARSER_OK
);
15012 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15014 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15016 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15018 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15020 salt_t
*salt
= hash_buf
->salt
;
15022 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15028 char *version_pos
= input_buf
+ 8 + 1;
15030 char *spinCount_pos
= strchr (version_pos
, '*');
15032 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15034 uint32_t version_len
= spinCount_pos
- version_pos
;
15036 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15040 char *keySize_pos
= strchr (spinCount_pos
, '*');
15042 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15044 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
15046 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15050 char *saltSize_pos
= strchr (keySize_pos
, '*');
15052 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15054 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
15056 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15060 char *osalt_pos
= strchr (saltSize_pos
, '*');
15062 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15064 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
15066 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15070 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15072 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15074 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15076 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15078 encryptedVerifier_pos
++;
15080 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15082 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15084 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15086 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15088 encryptedVerifierHash_pos
++;
15090 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;
15092 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15094 const uint version
= atoi (version_pos
);
15096 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15098 const uint spinCount
= atoi (spinCount_pos
);
15100 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15102 const uint keySize
= atoi (keySize_pos
);
15104 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15106 const uint saltSize
= atoi (saltSize_pos
);
15108 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15114 salt
->salt_len
= 16;
15115 salt
->salt_iter
= spinCount
;
15117 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15118 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15119 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15120 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15126 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15127 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15128 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15129 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15131 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15132 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15133 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15134 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15135 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15136 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15137 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15138 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15144 digest
[0] = office2013
->encryptedVerifierHash
[0];
15145 digest
[1] = office2013
->encryptedVerifierHash
[1];
15146 digest
[2] = office2013
->encryptedVerifierHash
[2];
15147 digest
[3] = office2013
->encryptedVerifierHash
[3];
15149 return (PARSER_OK
);
15152 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15154 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15156 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15158 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15160 salt_t
*salt
= hash_buf
->salt
;
15162 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15168 char *version_pos
= input_buf
+ 11;
15170 char *osalt_pos
= strchr (version_pos
, '*');
15172 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15174 uint32_t version_len
= osalt_pos
- version_pos
;
15176 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15180 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15182 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15184 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15186 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15188 encryptedVerifier_pos
++;
15190 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15192 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15194 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15196 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15198 encryptedVerifierHash_pos
++;
15200 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15202 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15204 const uint version
= *version_pos
- 0x30;
15206 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15212 oldoffice01
->version
= version
;
15214 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15215 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15216 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15217 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15219 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15220 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15221 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15222 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15224 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15225 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15226 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15227 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15229 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15230 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15231 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15232 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15238 salt
->salt_len
= 16;
15240 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15241 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15242 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15243 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15245 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15246 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15247 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15248 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15250 // this is a workaround as office produces multiple documents with the same salt
15252 salt
->salt_len
+= 32;
15254 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15255 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15256 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15257 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15258 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15259 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15260 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15261 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15267 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15268 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15269 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15270 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15272 return (PARSER_OK
);
15275 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15277 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15280 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15282 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15284 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15286 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15288 salt_t
*salt
= hash_buf
->salt
;
15290 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15296 char *version_pos
= input_buf
+ 11;
15298 char *osalt_pos
= strchr (version_pos
, '*');
15300 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15302 uint32_t version_len
= osalt_pos
- version_pos
;
15304 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15308 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15310 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15312 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15314 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15316 encryptedVerifier_pos
++;
15318 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15320 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15322 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15324 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15326 encryptedVerifierHash_pos
++;
15328 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15330 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15332 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15334 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15338 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15340 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15342 const uint version
= *version_pos
- 0x30;
15344 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15350 oldoffice01
->version
= version
;
15352 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15353 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15354 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15355 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15357 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15358 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15359 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15360 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15362 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15363 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15364 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15365 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15367 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15368 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15369 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15370 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15372 oldoffice01
->rc4key
[1] = 0;
15373 oldoffice01
->rc4key
[0] = 0;
15375 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15376 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15377 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15378 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15379 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15380 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15381 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15382 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15383 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15384 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15386 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15387 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15393 salt
->salt_len
= 16;
15395 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15396 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15397 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15398 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15400 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15401 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15402 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15403 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15405 // this is a workaround as office produces multiple documents with the same salt
15407 salt
->salt_len
+= 32;
15409 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15410 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15411 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15412 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15413 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15414 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15415 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15416 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15422 digest
[0] = oldoffice01
->rc4key
[0];
15423 digest
[1] = oldoffice01
->rc4key
[1];
15427 return (PARSER_OK
);
15430 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15432 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15434 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15436 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15438 salt_t
*salt
= hash_buf
->salt
;
15440 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15446 char *version_pos
= input_buf
+ 11;
15448 char *osalt_pos
= strchr (version_pos
, '*');
15450 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15452 uint32_t version_len
= osalt_pos
- version_pos
;
15454 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15458 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15460 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15462 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15464 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15466 encryptedVerifier_pos
++;
15468 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15470 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15472 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15474 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15476 encryptedVerifierHash_pos
++;
15478 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15480 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15482 const uint version
= *version_pos
- 0x30;
15484 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15490 oldoffice34
->version
= version
;
15492 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15493 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15494 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15495 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15497 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15498 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15499 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15500 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15502 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15503 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15504 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15505 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15506 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15508 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15509 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15510 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15511 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15512 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15518 salt
->salt_len
= 16;
15520 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15521 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15522 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15523 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15525 // this is a workaround as office produces multiple documents with the same salt
15527 salt
->salt_len
+= 32;
15529 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15530 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15531 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15532 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15533 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15534 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15535 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15536 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15542 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15543 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15544 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15545 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15547 return (PARSER_OK
);
15550 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15552 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15554 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15557 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15559 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15561 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15563 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15565 salt_t
*salt
= hash_buf
->salt
;
15567 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15573 char *version_pos
= input_buf
+ 11;
15575 char *osalt_pos
= strchr (version_pos
, '*');
15577 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15579 uint32_t version_len
= osalt_pos
- version_pos
;
15581 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15585 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15587 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15589 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15591 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15593 encryptedVerifier_pos
++;
15595 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15597 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15599 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15601 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15603 encryptedVerifierHash_pos
++;
15605 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15607 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15609 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15611 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15615 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15617 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15619 const uint version
= *version_pos
- 0x30;
15621 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15627 oldoffice34
->version
= version
;
15629 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15630 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15631 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15632 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15634 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15635 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15636 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15637 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15639 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15640 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15641 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15642 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15643 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15645 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15646 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15647 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15648 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15649 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15651 oldoffice34
->rc4key
[1] = 0;
15652 oldoffice34
->rc4key
[0] = 0;
15654 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15655 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15656 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15657 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15658 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15659 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15660 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15661 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15662 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15663 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15665 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15666 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15672 salt
->salt_len
= 16;
15674 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15675 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15676 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15677 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15679 // this is a workaround as office produces multiple documents with the same salt
15681 salt
->salt_len
+= 32;
15683 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15684 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15685 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15686 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15687 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15688 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15689 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15690 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15696 digest
[0] = oldoffice34
->rc4key
[0];
15697 digest
[1] = oldoffice34
->rc4key
[1];
15701 return (PARSER_OK
);
15704 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15706 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15708 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15710 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15711 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15712 digest
[2] = hex_to_uint (&input_buf
[16]);
15713 digest
[3] = hex_to_uint (&input_buf
[24]);
15715 digest
[0] = byte_swap_32 (digest
[0]);
15716 digest
[1] = byte_swap_32 (digest
[1]);
15717 digest
[2] = byte_swap_32 (digest
[2]);
15718 digest
[3] = byte_swap_32 (digest
[3]);
15720 return (PARSER_OK
);
15723 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15725 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15727 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15729 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15731 salt_t
*salt
= hash_buf
->salt
;
15733 char *signature_pos
= input_buf
;
15735 char *salt_pos
= strchr (signature_pos
, '$');
15737 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15739 uint32_t signature_len
= salt_pos
- signature_pos
;
15741 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15745 char *hash_pos
= strchr (salt_pos
, '$');
15747 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15749 uint32_t salt_len
= hash_pos
- salt_pos
;
15751 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15755 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15757 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15759 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15760 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15761 digest
[2] = hex_to_uint (&hash_pos
[16]);
15762 digest
[3] = hex_to_uint (&hash_pos
[24]);
15763 digest
[4] = hex_to_uint (&hash_pos
[32]);
15765 digest
[0] -= SHA1M_A
;
15766 digest
[1] -= SHA1M_B
;
15767 digest
[2] -= SHA1M_C
;
15768 digest
[3] -= SHA1M_D
;
15769 digest
[4] -= SHA1M_E
;
15771 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15773 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15775 salt
->salt_len
= salt_len
;
15777 return (PARSER_OK
);
15780 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15782 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15784 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15786 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15788 salt_t
*salt
= hash_buf
->salt
;
15790 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15796 char *iter_pos
= input_buf
+ 14;
15798 const int iter
= atoi (iter_pos
);
15800 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15802 salt
->salt_iter
= iter
- 1;
15804 char *salt_pos
= strchr (iter_pos
, '$');
15806 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15810 char *hash_pos
= strchr (salt_pos
, '$');
15812 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15814 const uint salt_len
= hash_pos
- salt_pos
;
15818 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15820 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15822 salt
->salt_len
= salt_len
;
15824 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15825 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15827 // add some stuff to normal salt to make sorted happy
15829 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15830 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15831 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15832 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15833 salt
->salt_buf
[4] = salt
->salt_iter
;
15835 // base64 decode hash
15839 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15841 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15843 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15845 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15847 memcpy (digest
, tmp_buf
, 32);
15849 digest
[0] = byte_swap_32 (digest
[0]);
15850 digest
[1] = byte_swap_32 (digest
[1]);
15851 digest
[2] = byte_swap_32 (digest
[2]);
15852 digest
[3] = byte_swap_32 (digest
[3]);
15853 digest
[4] = byte_swap_32 (digest
[4]);
15854 digest
[5] = byte_swap_32 (digest
[5]);
15855 digest
[6] = byte_swap_32 (digest
[6]);
15856 digest
[7] = byte_swap_32 (digest
[7]);
15858 return (PARSER_OK
);
15861 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15863 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15865 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15867 salt_t
*salt
= hash_buf
->salt
;
15869 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15870 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15874 digest
[0] = byte_swap_32 (digest
[0]);
15875 digest
[1] = byte_swap_32 (digest
[1]);
15877 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15878 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15879 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15881 char iter_c
= input_buf
[17];
15882 char iter_d
= input_buf
[19];
15884 // atm only defaults, let's see if there's more request
15885 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15886 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15888 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15890 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15891 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15892 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15893 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15895 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15896 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15897 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15898 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15900 salt
->salt_len
= 16;
15902 return (PARSER_OK
);
15905 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15907 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15909 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15911 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15913 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15915 salt_t
*salt
= hash_buf
->salt
;
15917 char *salt_pos
= input_buf
+ 10;
15919 char *hash_pos
= strchr (salt_pos
, '$');
15921 uint salt_len
= hash_pos
- salt_pos
;
15923 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15927 uint hash_len
= input_len
- 10 - salt_len
- 1;
15929 // base64 decode salt
15933 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15935 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15937 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15939 tmp_buf
[salt_len
] = 0x80;
15941 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15943 salt
->salt_len
= salt_len
;
15945 // base64 decode salt
15947 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15949 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15951 uint user_len
= hash_len
- 32;
15953 char *tmp_hash
= tmp_buf
+ user_len
;
15955 user_len
--; // skip the trailing space
15957 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15958 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15959 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15960 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15962 digest
[0] = byte_swap_32 (digest
[0]);
15963 digest
[1] = byte_swap_32 (digest
[1]);
15964 digest
[2] = byte_swap_32 (digest
[2]);
15965 digest
[3] = byte_swap_32 (digest
[3]);
15967 // store username for host only (output hash if cracked)
15969 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15970 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15972 return (PARSER_OK
);
15975 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15977 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15979 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15981 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15983 salt_t
*salt
= hash_buf
->salt
;
15985 char *iter_pos
= input_buf
+ 10;
15987 uint32_t iter
= atoi (iter_pos
);
15991 return (PARSER_SALT_ITERATION
);
15994 iter
--; // first iteration is special
15996 salt
->salt_iter
= iter
;
15998 char *base64_pos
= strchr (iter_pos
, '}');
16000 if (base64_pos
== NULL
)
16002 return (PARSER_SIGNATURE_UNMATCHED
);
16007 // base64 decode salt
16009 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
16013 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16015 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
16017 if (decoded_len
< 24)
16019 return (PARSER_SALT_LENGTH
);
16024 uint salt_len
= decoded_len
- 20;
16026 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16027 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16029 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16031 salt
->salt_len
= salt_len
;
16035 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
16037 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16038 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16039 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16040 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16041 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16043 return (PARSER_OK
);
16046 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16048 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16050 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16052 salt_t
*salt
= hash_buf
->salt
;
16054 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16055 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16056 digest
[2] = hex_to_uint (&input_buf
[16]);
16057 digest
[3] = hex_to_uint (&input_buf
[24]);
16058 digest
[4] = hex_to_uint (&input_buf
[32]);
16060 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16062 uint salt_len
= input_len
- 40 - 1;
16064 char *salt_buf
= input_buf
+ 40 + 1;
16066 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16068 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16070 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16072 salt
->salt_len
= salt_len
;
16074 return (PARSER_OK
);
16077 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16079 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16081 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16083 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16085 salt_t
*salt
= hash_buf
->salt
;
16087 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16093 char *V_pos
= input_buf
+ 5;
16095 char *R_pos
= strchr (V_pos
, '*');
16097 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16099 uint32_t V_len
= R_pos
- V_pos
;
16103 char *bits_pos
= strchr (R_pos
, '*');
16105 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16107 uint32_t R_len
= bits_pos
- R_pos
;
16111 char *P_pos
= strchr (bits_pos
, '*');
16113 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16115 uint32_t bits_len
= P_pos
- bits_pos
;
16119 char *enc_md_pos
= strchr (P_pos
, '*');
16121 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16123 uint32_t P_len
= enc_md_pos
- P_pos
;
16127 char *id_len_pos
= strchr (enc_md_pos
, '*');
16129 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16131 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16135 char *id_buf_pos
= strchr (id_len_pos
, '*');
16137 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16139 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16143 char *u_len_pos
= strchr (id_buf_pos
, '*');
16145 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16147 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16149 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16153 char *u_buf_pos
= strchr (u_len_pos
, '*');
16155 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16157 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16161 char *o_len_pos
= strchr (u_buf_pos
, '*');
16163 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16165 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16167 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16171 char *o_buf_pos
= strchr (o_len_pos
, '*');
16173 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16175 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16179 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;
16181 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16185 const int V
= atoi (V_pos
);
16186 const int R
= atoi (R_pos
);
16187 const int P
= atoi (P_pos
);
16189 if (V
!= 1) return (PARSER_SALT_VALUE
);
16190 if (R
!= 2) return (PARSER_SALT_VALUE
);
16192 const int enc_md
= atoi (enc_md_pos
);
16194 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16196 const int id_len
= atoi (id_len_pos
);
16197 const int u_len
= atoi (u_len_pos
);
16198 const int o_len
= atoi (o_len_pos
);
16200 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16201 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16202 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16204 const int bits
= atoi (bits_pos
);
16206 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16208 // copy data to esalt
16214 pdf
->enc_md
= enc_md
;
16216 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16217 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16218 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16219 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16220 pdf
->id_len
= id_len
;
16222 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16223 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16224 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16225 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16226 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16227 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16228 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16229 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16230 pdf
->u_len
= u_len
;
16232 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16233 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16234 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16235 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16236 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16237 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16238 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16239 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16240 pdf
->o_len
= o_len
;
16242 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16243 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16244 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16245 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16247 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16248 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16249 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16250 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16251 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16252 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16253 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16254 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16256 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16257 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16258 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16259 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16260 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16261 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16262 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16263 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16265 // we use ID for salt, maybe needs to change, we will see...
16267 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16268 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16269 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16270 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16271 salt
->salt_len
= pdf
->id_len
;
16273 digest
[0] = pdf
->u_buf
[0];
16274 digest
[1] = pdf
->u_buf
[1];
16275 digest
[2] = pdf
->u_buf
[2];
16276 digest
[3] = pdf
->u_buf
[3];
16278 return (PARSER_OK
);
16281 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16283 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16286 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16288 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16290 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16292 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16294 salt_t
*salt
= hash_buf
->salt
;
16296 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16302 char *V_pos
= input_buf
+ 5;
16304 char *R_pos
= strchr (V_pos
, '*');
16306 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16308 uint32_t V_len
= R_pos
- V_pos
;
16312 char *bits_pos
= strchr (R_pos
, '*');
16314 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16316 uint32_t R_len
= bits_pos
- R_pos
;
16320 char *P_pos
= strchr (bits_pos
, '*');
16322 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16324 uint32_t bits_len
= P_pos
- bits_pos
;
16328 char *enc_md_pos
= strchr (P_pos
, '*');
16330 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16332 uint32_t P_len
= enc_md_pos
- P_pos
;
16336 char *id_len_pos
= strchr (enc_md_pos
, '*');
16338 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16340 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16344 char *id_buf_pos
= strchr (id_len_pos
, '*');
16346 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16348 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16352 char *u_len_pos
= strchr (id_buf_pos
, '*');
16354 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16356 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16358 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16362 char *u_buf_pos
= strchr (u_len_pos
, '*');
16364 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16366 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16370 char *o_len_pos
= strchr (u_buf_pos
, '*');
16372 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16374 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16376 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16380 char *o_buf_pos
= strchr (o_len_pos
, '*');
16382 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16384 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16388 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16390 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16392 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16394 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16398 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;
16400 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16404 const int V
= atoi (V_pos
);
16405 const int R
= atoi (R_pos
);
16406 const int P
= atoi (P_pos
);
16408 if (V
!= 1) return (PARSER_SALT_VALUE
);
16409 if (R
!= 2) return (PARSER_SALT_VALUE
);
16411 const int enc_md
= atoi (enc_md_pos
);
16413 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16415 const int id_len
= atoi (id_len_pos
);
16416 const int u_len
= atoi (u_len_pos
);
16417 const int o_len
= atoi (o_len_pos
);
16419 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16420 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16421 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16423 const int bits
= atoi (bits_pos
);
16425 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16427 // copy data to esalt
16433 pdf
->enc_md
= enc_md
;
16435 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16436 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16437 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16438 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16439 pdf
->id_len
= id_len
;
16441 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16442 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16443 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16444 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16445 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16446 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16447 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16448 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16449 pdf
->u_len
= u_len
;
16451 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16452 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16453 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16454 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16455 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16456 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16457 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16458 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16459 pdf
->o_len
= o_len
;
16461 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16462 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16463 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16464 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16466 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16467 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16468 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16469 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16470 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16471 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16472 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16473 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16475 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16476 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16477 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16478 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16479 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16480 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16481 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16482 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16484 pdf
->rc4key
[1] = 0;
16485 pdf
->rc4key
[0] = 0;
16487 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16488 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16489 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16490 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16491 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16492 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16493 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16494 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16495 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16496 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16498 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16499 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16501 // we use ID for salt, maybe needs to change, we will see...
16503 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16504 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16505 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16506 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16507 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16508 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16509 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16510 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16511 salt
->salt_len
= pdf
->id_len
+ 16;
16513 digest
[0] = pdf
->rc4key
[0];
16514 digest
[1] = pdf
->rc4key
[1];
16518 return (PARSER_OK
);
16521 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16523 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16525 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16527 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16529 salt_t
*salt
= hash_buf
->salt
;
16531 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16537 char *V_pos
= input_buf
+ 5;
16539 char *R_pos
= strchr (V_pos
, '*');
16541 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16543 uint32_t V_len
= R_pos
- V_pos
;
16547 char *bits_pos
= strchr (R_pos
, '*');
16549 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16551 uint32_t R_len
= bits_pos
- R_pos
;
16555 char *P_pos
= strchr (bits_pos
, '*');
16557 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16559 uint32_t bits_len
= P_pos
- bits_pos
;
16563 char *enc_md_pos
= strchr (P_pos
, '*');
16565 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16567 uint32_t P_len
= enc_md_pos
- P_pos
;
16571 char *id_len_pos
= strchr (enc_md_pos
, '*');
16573 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16575 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16579 char *id_buf_pos
= strchr (id_len_pos
, '*');
16581 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16583 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16587 char *u_len_pos
= strchr (id_buf_pos
, '*');
16589 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16591 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16593 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16597 char *u_buf_pos
= strchr (u_len_pos
, '*');
16599 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16601 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16605 char *o_len_pos
= strchr (u_buf_pos
, '*');
16607 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16609 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16611 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16615 char *o_buf_pos
= strchr (o_len_pos
, '*');
16617 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16619 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16623 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;
16625 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16629 const int V
= atoi (V_pos
);
16630 const int R
= atoi (R_pos
);
16631 const int P
= atoi (P_pos
);
16635 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16636 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16638 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16640 const int id_len
= atoi (id_len_pos
);
16641 const int u_len
= atoi (u_len_pos
);
16642 const int o_len
= atoi (o_len_pos
);
16644 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16646 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16647 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16649 const int bits
= atoi (bits_pos
);
16651 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16657 enc_md
= atoi (enc_md_pos
);
16660 // copy data to esalt
16666 pdf
->enc_md
= enc_md
;
16668 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16669 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16670 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16671 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16675 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16676 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16677 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16678 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16681 pdf
->id_len
= id_len
;
16683 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16684 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16685 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16686 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16687 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16688 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16689 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16690 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16691 pdf
->u_len
= u_len
;
16693 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16694 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16695 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16696 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16697 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16698 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16699 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16700 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16701 pdf
->o_len
= o_len
;
16703 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16704 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16705 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16706 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16710 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16711 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16712 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16713 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16716 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16717 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16718 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16719 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16720 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16721 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16722 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16723 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16725 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16726 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16727 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16728 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16729 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16730 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16731 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16732 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16734 // precompute rc4 data for later use
16750 uint salt_pc_block
[32];
16752 char *salt_pc_ptr
= (char *) salt_pc_block
;
16754 memcpy (salt_pc_ptr
, padding
, 32);
16755 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16757 uint salt_pc_digest
[4];
16759 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16761 pdf
->rc4data
[0] = salt_pc_digest
[0];
16762 pdf
->rc4data
[1] = salt_pc_digest
[1];
16764 // we use ID for salt, maybe needs to change, we will see...
16766 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16767 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16768 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16769 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16770 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16771 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16772 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16773 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16774 salt
->salt_len
= pdf
->id_len
+ 16;
16776 salt
->salt_iter
= ROUNDS_PDF14
;
16778 digest
[0] = pdf
->u_buf
[0];
16779 digest
[1] = pdf
->u_buf
[1];
16783 return (PARSER_OK
);
16786 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16788 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16790 if (ret
!= PARSER_OK
)
16795 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16797 salt_t
*salt
= hash_buf
->salt
;
16799 digest
[0] -= SHA256M_A
;
16800 digest
[1] -= SHA256M_B
;
16801 digest
[2] -= SHA256M_C
;
16802 digest
[3] -= SHA256M_D
;
16803 digest
[4] -= SHA256M_E
;
16804 digest
[5] -= SHA256M_F
;
16805 digest
[6] -= SHA256M_G
;
16806 digest
[7] -= SHA256M_H
;
16808 salt
->salt_buf
[2] = 0x80;
16810 return (PARSER_OK
);
16813 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16815 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16817 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16819 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16821 salt_t
*salt
= hash_buf
->salt
;
16823 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16829 char *V_pos
= input_buf
+ 5;
16831 char *R_pos
= strchr (V_pos
, '*');
16833 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16835 uint32_t V_len
= R_pos
- V_pos
;
16839 char *bits_pos
= strchr (R_pos
, '*');
16841 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16843 uint32_t R_len
= bits_pos
- R_pos
;
16847 char *P_pos
= strchr (bits_pos
, '*');
16849 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16851 uint32_t bits_len
= P_pos
- bits_pos
;
16855 char *enc_md_pos
= strchr (P_pos
, '*');
16857 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16859 uint32_t P_len
= enc_md_pos
- P_pos
;
16863 char *id_len_pos
= strchr (enc_md_pos
, '*');
16865 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16867 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16871 char *id_buf_pos
= strchr (id_len_pos
, '*');
16873 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16875 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16879 char *u_len_pos
= strchr (id_buf_pos
, '*');
16881 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16883 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16887 char *u_buf_pos
= strchr (u_len_pos
, '*');
16889 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16891 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16895 char *o_len_pos
= strchr (u_buf_pos
, '*');
16897 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16899 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16903 char *o_buf_pos
= strchr (o_len_pos
, '*');
16905 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16907 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16911 char *last
= strchr (o_buf_pos
, '*');
16913 if (last
== NULL
) last
= input_buf
+ input_len
;
16915 uint32_t o_buf_len
= last
- o_buf_pos
;
16919 const int V
= atoi (V_pos
);
16920 const int R
= atoi (R_pos
);
16924 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16925 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16927 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16929 const int bits
= atoi (bits_pos
);
16931 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16933 int enc_md
= atoi (enc_md_pos
);
16935 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16937 const uint id_len
= atoi (id_len_pos
);
16938 const uint u_len
= atoi (u_len_pos
);
16939 const uint o_len
= atoi (o_len_pos
);
16941 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16942 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16943 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16944 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16945 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16946 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16947 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16948 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16950 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16951 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16952 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16954 // copy data to esalt
16956 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16958 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16960 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16963 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16964 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16966 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16967 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16969 salt
->salt_len
= 8;
16970 salt
->salt_iter
= ROUNDS_PDF17L8
;
16972 digest
[0] = pdf
->u_buf
[0];
16973 digest
[1] = pdf
->u_buf
[1];
16974 digest
[2] = pdf
->u_buf
[2];
16975 digest
[3] = pdf
->u_buf
[3];
16976 digest
[4] = pdf
->u_buf
[4];
16977 digest
[5] = pdf
->u_buf
[5];
16978 digest
[6] = pdf
->u_buf
[6];
16979 digest
[7] = pdf
->u_buf
[7];
16981 return (PARSER_OK
);
16984 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16986 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16988 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16990 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16992 salt_t
*salt
= hash_buf
->salt
;
16994 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17002 char *iter_pos
= input_buf
+ 7;
17004 uint32_t iter
= atoi (iter_pos
);
17006 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17007 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17009 // first is *raw* salt
17011 char *salt_pos
= strchr (iter_pos
, ':');
17013 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17017 char *hash_pos
= strchr (salt_pos
, ':');
17019 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17021 uint32_t salt_len
= hash_pos
- salt_pos
;
17023 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17027 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17029 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17033 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17035 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17037 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17039 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17040 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17042 salt
->salt_len
= salt_len
;
17043 salt
->salt_iter
= iter
- 1;
17049 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17051 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17053 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17055 memcpy (digest
, tmp_buf
, 16);
17057 digest
[0] = byte_swap_32 (digest
[0]);
17058 digest
[1] = byte_swap_32 (digest
[1]);
17059 digest
[2] = byte_swap_32 (digest
[2]);
17060 digest
[3] = byte_swap_32 (digest
[3]);
17062 // add some stuff to normal salt to make sorted happy
17064 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17065 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17066 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17067 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17068 salt
->salt_buf
[4] = salt
->salt_iter
;
17070 return (PARSER_OK
);
17073 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17075 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17077 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17079 salt_t
*salt
= hash_buf
->salt
;
17081 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17082 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17083 digest
[2] = hex_to_uint (&input_buf
[16]);
17084 digest
[3] = hex_to_uint (&input_buf
[24]);
17086 digest
[0] = byte_swap_32 (digest
[0]);
17087 digest
[1] = byte_swap_32 (digest
[1]);
17088 digest
[2] = byte_swap_32 (digest
[2]);
17089 digest
[3] = byte_swap_32 (digest
[3]);
17091 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17093 uint salt_len
= input_len
- 32 - 1;
17095 char *salt_buf
= input_buf
+ 32 + 1;
17097 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17099 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17101 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17103 salt
->salt_len
= salt_len
;
17105 return (PARSER_OK
);
17108 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17110 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17112 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17114 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17116 salt_t
*salt
= hash_buf
->salt
;
17118 char *user_pos
= input_buf
+ 10;
17120 char *salt_pos
= strchr (user_pos
, '*');
17122 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17126 char *hash_pos
= strchr (salt_pos
, '*');
17130 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17132 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17134 uint user_len
= salt_pos
- user_pos
- 1;
17136 uint salt_len
= hash_pos
- salt_pos
- 1;
17138 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17144 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17145 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17146 digest
[2] = hex_to_uint (&hash_pos
[16]);
17147 digest
[3] = hex_to_uint (&hash_pos
[24]);
17149 digest
[0] = byte_swap_32 (digest
[0]);
17150 digest
[1] = byte_swap_32 (digest
[1]);
17151 digest
[2] = byte_swap_32 (digest
[2]);
17152 digest
[3] = byte_swap_32 (digest
[3]);
17154 digest
[0] -= MD5M_A
;
17155 digest
[1] -= MD5M_B
;
17156 digest
[2] -= MD5M_C
;
17157 digest
[3] -= MD5M_D
;
17163 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17165 // first 4 bytes are the "challenge"
17167 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17168 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17169 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17170 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17172 // append the user name
17174 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17176 salt
->salt_len
= 4 + user_len
;
17178 return (PARSER_OK
);
17181 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17183 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17185 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17187 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17189 salt_t
*salt
= hash_buf
->salt
;
17191 char *salt_pos
= input_buf
+ 9;
17193 char *hash_pos
= strchr (salt_pos
, '*');
17195 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17199 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17201 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17203 uint salt_len
= hash_pos
- salt_pos
- 1;
17205 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17211 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17212 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17213 digest
[2] = hex_to_uint (&hash_pos
[16]);
17214 digest
[3] = hex_to_uint (&hash_pos
[24]);
17215 digest
[4] = hex_to_uint (&hash_pos
[32]);
17221 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17223 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17225 salt
->salt_len
= salt_len
;
17227 return (PARSER_OK
);
17230 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17232 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17234 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17236 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17238 salt_t
*salt
= hash_buf
->salt
;
17240 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17246 char *cry_master_len_pos
= input_buf
+ 9;
17248 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17250 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17252 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17254 cry_master_buf_pos
++;
17256 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17258 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17260 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17262 cry_salt_len_pos
++;
17264 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17266 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17268 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17270 cry_salt_buf_pos
++;
17272 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17274 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17276 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17280 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17282 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17288 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17290 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17296 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17298 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17302 public_key_len_pos
++;
17304 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17306 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17308 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17310 public_key_buf_pos
++;
17312 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;
17314 const uint cry_master_len
= atoi (cry_master_len_pos
);
17315 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17316 const uint ckey_len
= atoi (ckey_len_pos
);
17317 const uint public_key_len
= atoi (public_key_len_pos
);
17319 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17320 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17321 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17322 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17324 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17326 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17328 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17331 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17333 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17335 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17338 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17340 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17342 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17345 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17346 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17347 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17350 * store digest (should be unique enought, hopefully)
17353 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17354 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17355 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17356 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17362 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17364 const uint cry_rounds
= atoi (cry_rounds_pos
);
17366 salt
->salt_iter
= cry_rounds
- 1;
17368 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17370 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17372 salt
->salt_len
= salt_len
;
17374 return (PARSER_OK
);
17377 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17379 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17381 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17383 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17385 salt_t
*salt
= hash_buf
->salt
;
17387 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17389 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17391 char temp_input_buf
[input_len
+ 1];
17393 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17394 memcpy (temp_input_buf
, input_buf
, input_len
);
17398 char *URI_server_pos
= temp_input_buf
+ 6;
17400 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17402 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17404 URI_client_pos
[0] = 0;
17407 uint URI_server_len
= strlen (URI_server_pos
);
17409 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17413 char *user_pos
= strchr (URI_client_pos
, '*');
17415 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17420 uint URI_client_len
= strlen (URI_client_pos
);
17422 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17426 char *realm_pos
= strchr (user_pos
, '*');
17428 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17433 uint user_len
= strlen (user_pos
);
17435 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17439 char *method_pos
= strchr (realm_pos
, '*');
17441 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17446 uint realm_len
= strlen (realm_pos
);
17448 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17452 char *URI_prefix_pos
= strchr (method_pos
, '*');
17454 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17456 URI_prefix_pos
[0] = 0;
17459 uint method_len
= strlen (method_pos
);
17461 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17465 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17467 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17469 URI_resource_pos
[0] = 0;
17470 URI_resource_pos
++;
17472 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17474 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17478 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17480 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17482 URI_suffix_pos
[0] = 0;
17485 uint URI_resource_len
= strlen (URI_resource_pos
);
17487 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17488 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17492 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17494 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17499 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17501 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17505 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17507 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17509 nonce_client_pos
[0] = 0;
17510 nonce_client_pos
++;
17512 uint nonce_len
= strlen (nonce_pos
);
17514 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17515 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17519 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17521 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17523 nonce_count_pos
[0] = 0;
17526 uint nonce_client_len
= strlen (nonce_client_pos
);
17528 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17532 char *qop_pos
= strchr (nonce_count_pos
, '*');
17534 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17539 uint nonce_count_len
= strlen (nonce_count_pos
);
17541 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17545 char *directive_pos
= strchr (qop_pos
, '*');
17547 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17549 directive_pos
[0] = 0;
17552 uint qop_len
= strlen (qop_pos
);
17554 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17558 char *digest_pos
= strchr (directive_pos
, '*');
17560 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17565 uint directive_len
= strlen (directive_pos
);
17567 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17569 if (memcmp (directive_pos
, "MD5", 3))
17571 log_info ("ERROR: only the MD5 directive is currently supported\n");
17573 return (PARSER_SIP_AUTH_DIRECTIVE
);
17577 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17582 uint md5_max_len
= 4 * 64;
17584 uint md5_remaining_len
= md5_max_len
;
17586 uint tmp_md5_buf
[md5_max_len
/ 4];
17588 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17590 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17592 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17594 md5_len
+= method_len
+ 1;
17595 tmp_md5_ptr
+= method_len
+ 1;
17597 if (URI_prefix_len
> 0)
17599 md5_remaining_len
= md5_max_len
- md5_len
;
17601 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17603 md5_len
+= URI_prefix_len
+ 1;
17604 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17607 md5_remaining_len
= md5_max_len
- md5_len
;
17609 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17611 md5_len
+= URI_resource_len
;
17612 tmp_md5_ptr
+= URI_resource_len
;
17614 if (URI_suffix_len
> 0)
17616 md5_remaining_len
= md5_max_len
- md5_len
;
17618 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17620 md5_len
+= 1 + URI_suffix_len
;
17623 uint tmp_digest
[4];
17625 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17627 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17628 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17629 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17630 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17636 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17638 uint esalt_len
= 0;
17640 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17642 // there are 2 possibilities for the esalt:
17644 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17646 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17648 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17650 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17662 esalt_len
= 1 + nonce_len
+ 1 + 32;
17664 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17666 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17674 // add 0x80 to esalt
17676 esalt_buf_ptr
[esalt_len
] = 0x80;
17678 sip
->esalt_len
= esalt_len
;
17684 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17686 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17688 uint max_salt_len
= 119;
17690 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17692 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17694 sip
->salt_len
= salt_len
;
17697 * fake salt (for sorting)
17700 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17704 uint fake_salt_len
= salt_len
;
17706 if (fake_salt_len
> max_salt_len
)
17708 fake_salt_len
= max_salt_len
;
17711 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17713 salt
->salt_len
= fake_salt_len
;
17719 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17720 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17721 digest
[2] = hex_to_uint (&digest_pos
[16]);
17722 digest
[3] = hex_to_uint (&digest_pos
[24]);
17724 digest
[0] = byte_swap_32 (digest
[0]);
17725 digest
[1] = byte_swap_32 (digest
[1]);
17726 digest
[2] = byte_swap_32 (digest
[2]);
17727 digest
[3] = byte_swap_32 (digest
[3]);
17729 return (PARSER_OK
);
17732 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17734 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17736 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17738 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17740 salt_t
*salt
= hash_buf
->salt
;
17744 char *digest_pos
= input_buf
;
17746 digest
[0] = hex_to_uint (&digest_pos
[0]);
17753 char *salt_buf
= input_buf
+ 8 + 1;
17757 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17759 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17761 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17763 salt
->salt_len
= salt_len
;
17765 return (PARSER_OK
);
17768 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17770 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17772 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17774 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17776 salt_t
*salt
= hash_buf
->salt
;
17778 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17784 char *p_buf_pos
= input_buf
+ 4;
17786 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17788 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17790 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17792 NumCyclesPower_pos
++;
17794 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17796 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17798 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17802 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17804 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17806 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17810 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17812 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17814 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17818 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17820 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17822 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17826 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17828 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17830 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17834 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17836 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17838 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17842 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17844 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17846 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17850 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17852 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17854 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17858 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;
17860 const uint iter
= atoi (NumCyclesPower_pos
);
17861 const uint crc
= atoi (crc_buf_pos
);
17862 const uint p_buf
= atoi (p_buf_pos
);
17863 const uint salt_len
= atoi (salt_len_pos
);
17864 const uint iv_len
= atoi (iv_len_pos
);
17865 const uint unpack_size
= atoi (unpack_size_pos
);
17866 const uint data_len
= atoi (data_len_pos
);
17872 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17873 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17875 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17877 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17879 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17885 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17886 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17887 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17888 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17890 seven_zip
->iv_len
= iv_len
;
17892 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17894 seven_zip
->salt_len
= 0;
17896 seven_zip
->crc
= crc
;
17898 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17900 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17902 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17905 seven_zip
->data_len
= data_len
;
17907 seven_zip
->unpack_size
= unpack_size
;
17911 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17912 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17913 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17914 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17916 salt
->salt_len
= 16;
17918 salt
->salt_sign
[0] = iter
;
17920 salt
->salt_iter
= 1 << iter
;
17931 return (PARSER_OK
);
17934 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17936 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17938 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17940 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17941 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17942 digest
[2] = hex_to_uint (&input_buf
[16]);
17943 digest
[3] = hex_to_uint (&input_buf
[24]);
17944 digest
[4] = hex_to_uint (&input_buf
[32]);
17945 digest
[5] = hex_to_uint (&input_buf
[40]);
17946 digest
[6] = hex_to_uint (&input_buf
[48]);
17947 digest
[7] = hex_to_uint (&input_buf
[56]);
17949 digest
[0] = byte_swap_32 (digest
[0]);
17950 digest
[1] = byte_swap_32 (digest
[1]);
17951 digest
[2] = byte_swap_32 (digest
[2]);
17952 digest
[3] = byte_swap_32 (digest
[3]);
17953 digest
[4] = byte_swap_32 (digest
[4]);
17954 digest
[5] = byte_swap_32 (digest
[5]);
17955 digest
[6] = byte_swap_32 (digest
[6]);
17956 digest
[7] = byte_swap_32 (digest
[7]);
17958 return (PARSER_OK
);
17961 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17963 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17965 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17967 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17968 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17969 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17970 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17971 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17972 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17973 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17974 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17975 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17976 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17977 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17978 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17979 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17980 digest
[13] = hex_to_uint (&input_buf
[104]);
17981 digest
[14] = hex_to_uint (&input_buf
[112]);
17982 digest
[15] = hex_to_uint (&input_buf
[120]);
17984 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17985 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17986 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17987 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17988 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17989 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17990 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17991 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17992 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17993 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17994 digest
[10] = byte_swap_32 (digest
[10]);
17995 digest
[11] = byte_swap_32 (digest
[11]);
17996 digest
[12] = byte_swap_32 (digest
[12]);
17997 digest
[13] = byte_swap_32 (digest
[13]);
17998 digest
[14] = byte_swap_32 (digest
[14]);
17999 digest
[15] = byte_swap_32 (digest
[15]);
18001 return (PARSER_OK
);
18004 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18006 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18008 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18010 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18012 salt_t
*salt
= hash_buf
->salt
;
18014 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18022 char *iter_pos
= input_buf
+ 4;
18024 uint32_t iter
= atoi (iter_pos
);
18026 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18027 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18029 // first is *raw* salt
18031 char *salt_pos
= strchr (iter_pos
, ':');
18033 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18037 char *hash_pos
= strchr (salt_pos
, ':');
18039 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18041 uint32_t salt_len
= hash_pos
- salt_pos
;
18043 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18047 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18049 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18053 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18055 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18057 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18059 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18060 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18062 salt
->salt_len
= salt_len
;
18063 salt
->salt_iter
= iter
- 1;
18069 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18071 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18073 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18075 memcpy (digest
, tmp_buf
, 16);
18077 // add some stuff to normal salt to make sorted happy
18079 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18080 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18081 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18082 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18083 salt
->salt_buf
[4] = salt
->salt_iter
;
18085 return (PARSER_OK
);
18088 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18090 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18092 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18094 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18096 salt_t
*salt
= hash_buf
->salt
;
18098 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18106 char *iter_pos
= input_buf
+ 5;
18108 uint32_t iter
= atoi (iter_pos
);
18110 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18111 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18113 // first is *raw* salt
18115 char *salt_pos
= strchr (iter_pos
, ':');
18117 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18121 char *hash_pos
= strchr (salt_pos
, ':');
18123 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18125 uint32_t salt_len
= hash_pos
- salt_pos
;
18127 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18131 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18133 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18137 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18139 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18141 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18143 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18144 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18146 salt
->salt_len
= salt_len
;
18147 salt
->salt_iter
= iter
- 1;
18153 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18155 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18157 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18159 memcpy (digest
, tmp_buf
, 16);
18161 digest
[0] = byte_swap_32 (digest
[0]);
18162 digest
[1] = byte_swap_32 (digest
[1]);
18163 digest
[2] = byte_swap_32 (digest
[2]);
18164 digest
[3] = byte_swap_32 (digest
[3]);
18166 // add some stuff to normal salt to make sorted happy
18168 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18169 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18170 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18171 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18172 salt
->salt_buf
[4] = salt
->salt_iter
;
18174 return (PARSER_OK
);
18177 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18179 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18181 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18183 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18185 salt_t
*salt
= hash_buf
->salt
;
18187 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18195 char *iter_pos
= input_buf
+ 7;
18197 uint32_t iter
= atoi (iter_pos
);
18199 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18200 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18202 // first is *raw* salt
18204 char *salt_pos
= strchr (iter_pos
, ':');
18206 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18210 char *hash_pos
= strchr (salt_pos
, ':');
18212 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18214 uint32_t salt_len
= hash_pos
- salt_pos
;
18216 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18220 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18222 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18226 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18228 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18230 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18232 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18233 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18235 salt
->salt_len
= salt_len
;
18236 salt
->salt_iter
= iter
- 1;
18242 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18244 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18246 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18248 memcpy (digest
, tmp_buf
, 64);
18250 digest
[0] = byte_swap_64 (digest
[0]);
18251 digest
[1] = byte_swap_64 (digest
[1]);
18252 digest
[2] = byte_swap_64 (digest
[2]);
18253 digest
[3] = byte_swap_64 (digest
[3]);
18254 digest
[4] = byte_swap_64 (digest
[4]);
18255 digest
[5] = byte_swap_64 (digest
[5]);
18256 digest
[6] = byte_swap_64 (digest
[6]);
18257 digest
[7] = byte_swap_64 (digest
[7]);
18259 // add some stuff to normal salt to make sorted happy
18261 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18262 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18263 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18264 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18265 salt
->salt_buf
[4] = salt
->salt_iter
;
18267 return (PARSER_OK
);
18270 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18272 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18274 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18276 uint
*digest
= (uint
*) hash_buf
->digest
;
18278 salt_t
*salt
= hash_buf
->salt
;
18284 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18286 char *hash_pos
= strchr (salt_pos
, '$');
18288 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18290 uint32_t salt_len
= hash_pos
- salt_pos
;
18292 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18296 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18298 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18302 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18303 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18321 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18322 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18324 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18325 salt
->salt_len
= 8;
18327 return (PARSER_OK
);
18330 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18332 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18334 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18336 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18338 if (c19
& 3) return (PARSER_HASH_VALUE
);
18340 salt_t
*salt
= hash_buf
->salt
;
18342 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18346 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18347 | itoa64_to_int (input_buf
[2]) << 6
18348 | itoa64_to_int (input_buf
[3]) << 12
18349 | itoa64_to_int (input_buf
[4]) << 18;
18353 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18354 | itoa64_to_int (input_buf
[6]) << 6
18355 | itoa64_to_int (input_buf
[7]) << 12
18356 | itoa64_to_int (input_buf
[8]) << 18;
18358 salt
->salt_len
= 4;
18362 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18364 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18366 memcpy (digest
, tmp_buf
, 8);
18370 IP (digest
[0], digest
[1], tt
);
18372 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18373 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18377 return (PARSER_OK
);
18380 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18382 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18384 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18386 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18388 salt_t
*salt
= hash_buf
->salt
;
18394 char *type_pos
= input_buf
+ 6 + 1;
18396 char *salt_pos
= strchr (type_pos
, '*');
18398 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18400 uint32_t type_len
= salt_pos
- type_pos
;
18402 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18406 char *crypted_pos
= strchr (salt_pos
, '*');
18408 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18410 uint32_t salt_len
= crypted_pos
- salt_pos
;
18412 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18416 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18418 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18424 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18425 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18427 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18428 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18430 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18431 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18432 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18433 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18435 salt
->salt_len
= 24;
18436 salt
->salt_iter
= ROUNDS_RAR3
;
18438 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18439 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18441 digest
[0] = 0xc43d7b00;
18442 digest
[1] = 0x40070000;
18446 return (PARSER_OK
);
18449 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18451 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18453 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18455 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18457 salt_t
*salt
= hash_buf
->salt
;
18459 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18465 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18467 char *param1_pos
= strchr (param0_pos
, '$');
18469 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18471 uint32_t param0_len
= param1_pos
- param0_pos
;
18475 char *param2_pos
= strchr (param1_pos
, '$');
18477 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18479 uint32_t param1_len
= param2_pos
- param1_pos
;
18483 char *param3_pos
= strchr (param2_pos
, '$');
18485 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18487 uint32_t param2_len
= param3_pos
- param2_pos
;
18491 char *param4_pos
= strchr (param3_pos
, '$');
18493 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18495 uint32_t param3_len
= param4_pos
- param3_pos
;
18499 char *param5_pos
= strchr (param4_pos
, '$');
18501 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18503 uint32_t param4_len
= param5_pos
- param4_pos
;
18507 uint32_t param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18509 char *salt_buf
= param1_pos
;
18510 char *iv
= param3_pos
;
18511 char *pswcheck
= param5_pos
;
18513 const uint salt_len
= atoi (param0_pos
);
18514 const uint iterations
= atoi (param2_pos
);
18515 const uint pswcheck_len
= atoi (param4_pos
);
18521 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18522 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18523 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18525 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18526 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18527 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18533 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
18534 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
18535 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
18536 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
18538 rar5
->iv
[0] = hex_to_uint (&iv
[ 0]);
18539 rar5
->iv
[1] = hex_to_uint (&iv
[ 8]);
18540 rar5
->iv
[2] = hex_to_uint (&iv
[16]);
18541 rar5
->iv
[3] = hex_to_uint (&iv
[24]);
18543 salt
->salt_len
= 16;
18545 salt
->salt_sign
[0] = iterations
;
18547 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18553 digest
[0] = hex_to_uint (&pswcheck
[ 0]);
18554 digest
[1] = hex_to_uint (&pswcheck
[ 8]);
18558 return (PARSER_OK
);
18561 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18563 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18565 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18567 salt_t
*salt
= hash_buf
->salt
;
18569 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18570 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18571 digest
[2] = hex_to_uint (&input_buf
[16]);
18572 digest
[3] = hex_to_uint (&input_buf
[24]);
18573 digest
[4] = hex_to_uint (&input_buf
[32]);
18574 digest
[5] = hex_to_uint (&input_buf
[40]);
18575 digest
[6] = hex_to_uint (&input_buf
[48]);
18576 digest
[7] = hex_to_uint (&input_buf
[56]);
18578 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18580 uint salt_len
= input_len
- 64 - 1;
18582 char *salt_buf
= input_buf
+ 64 + 1;
18584 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18586 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18588 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18590 salt
->salt_len
= salt_len
;
18593 * we can precompute the first sha256 transform
18598 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18599 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18600 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18601 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18602 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18603 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18604 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18605 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18606 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18607 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18608 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18609 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18610 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18611 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18612 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18613 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18617 pc256
[0] = SHA256M_A
;
18618 pc256
[1] = SHA256M_B
;
18619 pc256
[2] = SHA256M_C
;
18620 pc256
[3] = SHA256M_D
;
18621 pc256
[4] = SHA256M_E
;
18622 pc256
[5] = SHA256M_F
;
18623 pc256
[6] = SHA256M_G
;
18624 pc256
[7] = SHA256M_H
;
18626 sha256_64 (w
, pc256
);
18628 salt
->salt_buf_pc
[0] = pc256
[0];
18629 salt
->salt_buf_pc
[1] = pc256
[1];
18630 salt
->salt_buf_pc
[2] = pc256
[2];
18631 salt
->salt_buf_pc
[3] = pc256
[3];
18632 salt
->salt_buf_pc
[4] = pc256
[4];
18633 salt
->salt_buf_pc
[5] = pc256
[5];
18634 salt
->salt_buf_pc
[6] = pc256
[6];
18635 salt
->salt_buf_pc
[7] = pc256
[7];
18637 digest
[0] -= pc256
[0];
18638 digest
[1] -= pc256
[1];
18639 digest
[2] -= pc256
[2];
18640 digest
[3] -= pc256
[3];
18641 digest
[4] -= pc256
[4];
18642 digest
[5] -= pc256
[5];
18643 digest
[6] -= pc256
[6];
18644 digest
[7] -= pc256
[7];
18646 return (PARSER_OK
);
18649 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18651 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18653 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18655 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18657 salt_t
*salt
= hash_buf
->salt
;
18663 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18665 char *data_buf_pos
= strchr (data_len_pos
, '$');
18667 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18669 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18671 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18672 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18676 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18678 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18680 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18682 uint32_t data_len
= atoi (data_len_pos
);
18684 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18690 char *salt_pos
= data_buf_pos
;
18692 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18693 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18694 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18695 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18697 // this is actually the CT, which is also the hash later (if matched)
18699 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18700 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18701 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18702 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18704 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18706 salt
->salt_iter
= 10 - 1;
18712 digest
[0] = salt
->salt_buf
[4];
18713 digest
[1] = salt
->salt_buf
[5];
18714 digest
[2] = salt
->salt_buf
[6];
18715 digest
[3] = salt
->salt_buf
[7];
18717 return (PARSER_OK
);
18720 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18722 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18724 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18726 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18728 salt_t
*salt
= hash_buf
->salt
;
18734 char *salt_pos
= input_buf
+ 11 + 1;
18736 char *iter_pos
= strchr (salt_pos
, ',');
18738 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18740 uint32_t salt_len
= iter_pos
- salt_pos
;
18742 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18746 char *hash_pos
= strchr (iter_pos
, ',');
18748 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18750 uint32_t iter_len
= hash_pos
- iter_pos
;
18752 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18756 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18758 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18764 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18765 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18766 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18767 salt
->salt_buf
[3] = 0x00018000;
18769 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18770 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18771 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18772 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18774 salt
->salt_len
= salt_len
/ 2;
18776 salt
->salt_iter
= atoi (iter_pos
) - 1;
18782 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18783 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18784 digest
[2] = hex_to_uint (&hash_pos
[16]);
18785 digest
[3] = hex_to_uint (&hash_pos
[24]);
18786 digest
[4] = hex_to_uint (&hash_pos
[32]);
18787 digest
[5] = hex_to_uint (&hash_pos
[40]);
18788 digest
[6] = hex_to_uint (&hash_pos
[48]);
18789 digest
[7] = hex_to_uint (&hash_pos
[56]);
18791 return (PARSER_OK
);
18794 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18796 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18798 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18800 salt_t
*salt
= hash_buf
->salt
;
18806 char *hash_pos
= input_buf
+ 64;
18807 char *salt1_pos
= input_buf
+ 128;
18808 char *salt2_pos
= input_buf
;
18814 salt
->salt_buf
[ 0] = hex_to_uint (&salt1_pos
[ 0]);
18815 salt
->salt_buf
[ 1] = hex_to_uint (&salt1_pos
[ 8]);
18816 salt
->salt_buf
[ 2] = hex_to_uint (&salt1_pos
[16]);
18817 salt
->salt_buf
[ 3] = hex_to_uint (&salt1_pos
[24]);
18819 salt
->salt_buf
[ 4] = hex_to_uint (&salt2_pos
[ 0]);
18820 salt
->salt_buf
[ 5] = hex_to_uint (&salt2_pos
[ 8]);
18821 salt
->salt_buf
[ 6] = hex_to_uint (&salt2_pos
[16]);
18822 salt
->salt_buf
[ 7] = hex_to_uint (&salt2_pos
[24]);
18824 salt
->salt_buf
[ 8] = hex_to_uint (&salt2_pos
[32]);
18825 salt
->salt_buf
[ 9] = hex_to_uint (&salt2_pos
[40]);
18826 salt
->salt_buf
[10] = hex_to_uint (&salt2_pos
[48]);
18827 salt
->salt_buf
[11] = hex_to_uint (&salt2_pos
[56]);
18829 salt
->salt_len
= 48;
18831 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18837 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18838 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18839 digest
[2] = hex_to_uint (&hash_pos
[16]);
18840 digest
[3] = hex_to_uint (&hash_pos
[24]);
18841 digest
[4] = hex_to_uint (&hash_pos
[32]);
18842 digest
[5] = hex_to_uint (&hash_pos
[40]);
18843 digest
[6] = hex_to_uint (&hash_pos
[48]);
18844 digest
[7] = hex_to_uint (&hash_pos
[56]);
18846 return (PARSER_OK
);
18850 * parallel running threads
18855 BOOL WINAPI
sigHandler_default (DWORD sig
)
18859 case CTRL_CLOSE_EVENT
:
18862 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18863 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18864 * function otherwise it is to late (e.g. after returning from this function)
18869 SetConsoleCtrlHandler (NULL
, TRUE
);
18876 case CTRL_LOGOFF_EVENT
:
18877 case CTRL_SHUTDOWN_EVENT
:
18881 SetConsoleCtrlHandler (NULL
, TRUE
);
18889 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18893 case CTRL_CLOSE_EVENT
:
18897 SetConsoleCtrlHandler (NULL
, TRUE
);
18904 case CTRL_LOGOFF_EVENT
:
18905 case CTRL_SHUTDOWN_EVENT
:
18909 SetConsoleCtrlHandler (NULL
, TRUE
);
18917 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18919 if (callback
== NULL
)
18921 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18925 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18931 void sigHandler_default (int sig
)
18935 signal (sig
, NULL
);
18938 void sigHandler_benchmark (int sig
)
18942 signal (sig
, NULL
);
18945 void hc_signal (void (callback
) (int))
18947 if (callback
== NULL
) callback
= SIG_DFL
;
18949 signal (SIGINT
, callback
);
18950 signal (SIGTERM
, callback
);
18951 signal (SIGABRT
, callback
);
18956 void status_display ();
18958 void *thread_keypress (void *p
)
18960 int benchmark
= *((int *) p
);
18962 uint quiet
= data
.quiet
;
18966 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18968 int ch
= tty_getchar();
18970 if (ch
== -1) break;
18972 if (ch
== 0) continue;
18978 hc_thread_mutex_lock (mux_display
);
18993 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18994 if (quiet
== 0) fflush (stdout
);
19006 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19007 if (quiet
== 0) fflush (stdout
);
19019 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19020 if (quiet
== 0) fflush (stdout
);
19032 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19033 if (quiet
== 0) fflush (stdout
);
19041 if (benchmark
== 1) break;
19043 stop_at_checkpoint ();
19047 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19048 if (quiet
== 0) fflush (stdout
);
19056 if (benchmark
== 1)
19068 hc_thread_mutex_unlock (mux_display
);
19080 bool class_num (char c
)
19082 return ((c
>= '0') && (c
<= '9'));
19085 bool class_lower (char c
)
19087 return ((c
>= 'a') && (c
<= 'z'));
19090 bool class_upper (char c
)
19092 return ((c
>= 'A') && (c
<= 'Z'));
19095 bool class_alpha (char c
)
19097 return (class_lower (c
) || class_upper (c
));
19100 char conv_ctoi (char c
)
19106 else if (class_upper (c
))
19108 return c
- 'A' + (char) 10;
19111 return (char) (-1);
19114 char conv_itoc (char c
)
19122 return c
+ 'A' - (char) 10;
19125 return (char) (-1);
19132 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19133 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19134 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19135 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19136 #define MAX_KERNEL_RULES 255
19137 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19138 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19139 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19141 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19142 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19143 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19144 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19146 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19151 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19153 switch (rule_buf
[rule_pos
])
19159 case RULE_OP_MANGLE_NOOP
:
19160 SET_NAME (rule
, rule_buf
[rule_pos
]);
19163 case RULE_OP_MANGLE_LREST
:
19164 SET_NAME (rule
, rule_buf
[rule_pos
]);
19167 case RULE_OP_MANGLE_UREST
:
19168 SET_NAME (rule
, rule_buf
[rule_pos
]);
19171 case RULE_OP_MANGLE_LREST_UFIRST
:
19172 SET_NAME (rule
, rule_buf
[rule_pos
]);
19175 case RULE_OP_MANGLE_UREST_LFIRST
:
19176 SET_NAME (rule
, rule_buf
[rule_pos
]);
19179 case RULE_OP_MANGLE_TREST
:
19180 SET_NAME (rule
, rule_buf
[rule_pos
]);
19183 case RULE_OP_MANGLE_TOGGLE_AT
:
19184 SET_NAME (rule
, rule_buf
[rule_pos
]);
19185 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19188 case RULE_OP_MANGLE_REVERSE
:
19189 SET_NAME (rule
, rule_buf
[rule_pos
]);
19192 case RULE_OP_MANGLE_DUPEWORD
:
19193 SET_NAME (rule
, rule_buf
[rule_pos
]);
19196 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19197 SET_NAME (rule
, rule_buf
[rule_pos
]);
19198 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19201 case RULE_OP_MANGLE_REFLECT
:
19202 SET_NAME (rule
, rule_buf
[rule_pos
]);
19205 case RULE_OP_MANGLE_ROTATE_LEFT
:
19206 SET_NAME (rule
, rule_buf
[rule_pos
]);
19209 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19210 SET_NAME (rule
, rule_buf
[rule_pos
]);
19213 case RULE_OP_MANGLE_APPEND
:
19214 SET_NAME (rule
, rule_buf
[rule_pos
]);
19215 SET_P0 (rule
, rule_buf
[rule_pos
]);
19218 case RULE_OP_MANGLE_PREPEND
:
19219 SET_NAME (rule
, rule_buf
[rule_pos
]);
19220 SET_P0 (rule
, rule_buf
[rule_pos
]);
19223 case RULE_OP_MANGLE_DELETE_FIRST
:
19224 SET_NAME (rule
, rule_buf
[rule_pos
]);
19227 case RULE_OP_MANGLE_DELETE_LAST
:
19228 SET_NAME (rule
, rule_buf
[rule_pos
]);
19231 case RULE_OP_MANGLE_DELETE_AT
:
19232 SET_NAME (rule
, rule_buf
[rule_pos
]);
19233 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19236 case RULE_OP_MANGLE_EXTRACT
:
19237 SET_NAME (rule
, rule_buf
[rule_pos
]);
19238 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19239 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19242 case RULE_OP_MANGLE_OMIT
:
19243 SET_NAME (rule
, rule_buf
[rule_pos
]);
19244 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19245 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19248 case RULE_OP_MANGLE_INSERT
:
19249 SET_NAME (rule
, rule_buf
[rule_pos
]);
19250 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19251 SET_P1 (rule
, rule_buf
[rule_pos
]);
19254 case RULE_OP_MANGLE_OVERSTRIKE
:
19255 SET_NAME (rule
, rule_buf
[rule_pos
]);
19256 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19257 SET_P1 (rule
, rule_buf
[rule_pos
]);
19260 case RULE_OP_MANGLE_TRUNCATE_AT
:
19261 SET_NAME (rule
, rule_buf
[rule_pos
]);
19262 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19265 case RULE_OP_MANGLE_REPLACE
:
19266 SET_NAME (rule
, rule_buf
[rule_pos
]);
19267 SET_P0 (rule
, rule_buf
[rule_pos
]);
19268 SET_P1 (rule
, rule_buf
[rule_pos
]);
19271 case RULE_OP_MANGLE_PURGECHAR
:
19275 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19279 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19280 SET_NAME (rule
, rule_buf
[rule_pos
]);
19281 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19284 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19285 SET_NAME (rule
, rule_buf
[rule_pos
]);
19286 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19289 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19290 SET_NAME (rule
, rule_buf
[rule_pos
]);
19293 case RULE_OP_MANGLE_SWITCH_FIRST
:
19294 SET_NAME (rule
, rule_buf
[rule_pos
]);
19297 case RULE_OP_MANGLE_SWITCH_LAST
:
19298 SET_NAME (rule
, rule_buf
[rule_pos
]);
19301 case RULE_OP_MANGLE_SWITCH_AT
:
19302 SET_NAME (rule
, rule_buf
[rule_pos
]);
19303 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19304 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19307 case RULE_OP_MANGLE_CHR_SHIFTL
:
19308 SET_NAME (rule
, rule_buf
[rule_pos
]);
19309 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19312 case RULE_OP_MANGLE_CHR_SHIFTR
:
19313 SET_NAME (rule
, rule_buf
[rule_pos
]);
19314 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19317 case RULE_OP_MANGLE_CHR_INCR
:
19318 SET_NAME (rule
, rule_buf
[rule_pos
]);
19319 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19322 case RULE_OP_MANGLE_CHR_DECR
:
19323 SET_NAME (rule
, rule_buf
[rule_pos
]);
19324 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19327 case RULE_OP_MANGLE_REPLACE_NP1
:
19328 SET_NAME (rule
, rule_buf
[rule_pos
]);
19329 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19332 case RULE_OP_MANGLE_REPLACE_NM1
:
19333 SET_NAME (rule
, rule_buf
[rule_pos
]);
19334 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19337 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19338 SET_NAME (rule
, rule_buf
[rule_pos
]);
19339 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19342 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19343 SET_NAME (rule
, rule_buf
[rule_pos
]);
19344 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19347 case RULE_OP_MANGLE_TITLE
:
19348 SET_NAME (rule
, rule_buf
[rule_pos
]);
19357 if (rule_pos
< rule_len
) return (-1);
19362 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19366 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19370 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19374 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19378 case RULE_OP_MANGLE_NOOP
:
19379 rule_buf
[rule_pos
] = rule_cmd
;
19382 case RULE_OP_MANGLE_LREST
:
19383 rule_buf
[rule_pos
] = rule_cmd
;
19386 case RULE_OP_MANGLE_UREST
:
19387 rule_buf
[rule_pos
] = rule_cmd
;
19390 case RULE_OP_MANGLE_LREST_UFIRST
:
19391 rule_buf
[rule_pos
] = rule_cmd
;
19394 case RULE_OP_MANGLE_UREST_LFIRST
:
19395 rule_buf
[rule_pos
] = rule_cmd
;
19398 case RULE_OP_MANGLE_TREST
:
19399 rule_buf
[rule_pos
] = rule_cmd
;
19402 case RULE_OP_MANGLE_TOGGLE_AT
:
19403 rule_buf
[rule_pos
] = rule_cmd
;
19404 GET_P0_CONV (rule
);
19407 case RULE_OP_MANGLE_REVERSE
:
19408 rule_buf
[rule_pos
] = rule_cmd
;
19411 case RULE_OP_MANGLE_DUPEWORD
:
19412 rule_buf
[rule_pos
] = rule_cmd
;
19415 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19416 rule_buf
[rule_pos
] = rule_cmd
;
19417 GET_P0_CONV (rule
);
19420 case RULE_OP_MANGLE_REFLECT
:
19421 rule_buf
[rule_pos
] = rule_cmd
;
19424 case RULE_OP_MANGLE_ROTATE_LEFT
:
19425 rule_buf
[rule_pos
] = rule_cmd
;
19428 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19429 rule_buf
[rule_pos
] = rule_cmd
;
19432 case RULE_OP_MANGLE_APPEND
:
19433 rule_buf
[rule_pos
] = rule_cmd
;
19437 case RULE_OP_MANGLE_PREPEND
:
19438 rule_buf
[rule_pos
] = rule_cmd
;
19442 case RULE_OP_MANGLE_DELETE_FIRST
:
19443 rule_buf
[rule_pos
] = rule_cmd
;
19446 case RULE_OP_MANGLE_DELETE_LAST
:
19447 rule_buf
[rule_pos
] = rule_cmd
;
19450 case RULE_OP_MANGLE_DELETE_AT
:
19451 rule_buf
[rule_pos
] = rule_cmd
;
19452 GET_P0_CONV (rule
);
19455 case RULE_OP_MANGLE_EXTRACT
:
19456 rule_buf
[rule_pos
] = rule_cmd
;
19457 GET_P0_CONV (rule
);
19458 GET_P1_CONV (rule
);
19461 case RULE_OP_MANGLE_OMIT
:
19462 rule_buf
[rule_pos
] = rule_cmd
;
19463 GET_P0_CONV (rule
);
19464 GET_P1_CONV (rule
);
19467 case RULE_OP_MANGLE_INSERT
:
19468 rule_buf
[rule_pos
] = rule_cmd
;
19469 GET_P0_CONV (rule
);
19473 case RULE_OP_MANGLE_OVERSTRIKE
:
19474 rule_buf
[rule_pos
] = rule_cmd
;
19475 GET_P0_CONV (rule
);
19479 case RULE_OP_MANGLE_TRUNCATE_AT
:
19480 rule_buf
[rule_pos
] = rule_cmd
;
19481 GET_P0_CONV (rule
);
19484 case RULE_OP_MANGLE_REPLACE
:
19485 rule_buf
[rule_pos
] = rule_cmd
;
19490 case RULE_OP_MANGLE_PURGECHAR
:
19494 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19498 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19499 rule_buf
[rule_pos
] = rule_cmd
;
19500 GET_P0_CONV (rule
);
19503 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19504 rule_buf
[rule_pos
] = rule_cmd
;
19505 GET_P0_CONV (rule
);
19508 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19509 rule_buf
[rule_pos
] = rule_cmd
;
19512 case RULE_OP_MANGLE_SWITCH_FIRST
:
19513 rule_buf
[rule_pos
] = rule_cmd
;
19516 case RULE_OP_MANGLE_SWITCH_LAST
:
19517 rule_buf
[rule_pos
] = rule_cmd
;
19520 case RULE_OP_MANGLE_SWITCH_AT
:
19521 rule_buf
[rule_pos
] = rule_cmd
;
19522 GET_P0_CONV (rule
);
19523 GET_P1_CONV (rule
);
19526 case RULE_OP_MANGLE_CHR_SHIFTL
:
19527 rule_buf
[rule_pos
] = rule_cmd
;
19528 GET_P0_CONV (rule
);
19531 case RULE_OP_MANGLE_CHR_SHIFTR
:
19532 rule_buf
[rule_pos
] = rule_cmd
;
19533 GET_P0_CONV (rule
);
19536 case RULE_OP_MANGLE_CHR_INCR
:
19537 rule_buf
[rule_pos
] = rule_cmd
;
19538 GET_P0_CONV (rule
);
19541 case RULE_OP_MANGLE_CHR_DECR
:
19542 rule_buf
[rule_pos
] = rule_cmd
;
19543 GET_P0_CONV (rule
);
19546 case RULE_OP_MANGLE_REPLACE_NP1
:
19547 rule_buf
[rule_pos
] = rule_cmd
;
19548 GET_P0_CONV (rule
);
19551 case RULE_OP_MANGLE_REPLACE_NM1
:
19552 rule_buf
[rule_pos
] = rule_cmd
;
19553 GET_P0_CONV (rule
);
19556 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19557 rule_buf
[rule_pos
] = rule_cmd
;
19558 GET_P0_CONV (rule
);
19561 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19562 rule_buf
[rule_pos
] = rule_cmd
;
19563 GET_P0_CONV (rule
);
19566 case RULE_OP_MANGLE_TITLE
:
19567 rule_buf
[rule_pos
] = rule_cmd
;
19571 return rule_pos
- 1;
19589 * CPU rules : this is from hashcat sources, cpu based rules
19592 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19593 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19595 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19596 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19597 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19599 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19600 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19601 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19603 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19607 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19612 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19616 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19621 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19625 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19630 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19635 for (l
= 0; l
< arr_len
; l
++)
19637 r
= arr_len
- 1 - l
;
19641 MANGLE_SWITCH (arr
, l
, r
);
19647 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19649 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19651 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19653 return (arr_len
* 2);
19656 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19658 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19660 int orig_len
= arr_len
;
19664 for (i
= 0; i
< times
; i
++)
19666 memcpy (&arr
[arr_len
], arr
, orig_len
);
19668 arr_len
+= orig_len
;
19674 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19676 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19678 mangle_double (arr
, arr_len
);
19680 mangle_reverse (arr
+ arr_len
, arr_len
);
19682 return (arr_len
* 2);
19685 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19690 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19692 MANGLE_SWITCH (arr
, l
, r
);
19698 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19703 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19705 MANGLE_SWITCH (arr
, l
, r
);
19711 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19713 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19717 return (arr_len
+ 1);
19720 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19722 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19726 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19728 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19733 return (arr_len
+ 1);
19736 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19738 if (upos
>= arr_len
) return (arr_len
);
19742 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19744 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19747 return (arr_len
- 1);
19750 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19752 if (upos
>= arr_len
) return (arr_len
);
19754 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19758 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19760 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19766 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19768 if (upos
>= arr_len
) return (arr_len
);
19770 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19774 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19776 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19779 return (arr_len
- ulen
);
19782 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19784 if (upos
>= arr_len
) return (arr_len
);
19786 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19790 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19792 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19797 return (arr_len
+ 1);
19800 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
)
19802 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19804 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19806 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19808 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19810 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19812 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19814 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19816 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19818 return (arr_len
+ arr2_cpy
);
19821 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19823 if (upos
>= arr_len
) return (arr_len
);
19830 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19832 if (upos
>= arr_len
) return (arr_len
);
19834 memset (arr
+ upos
, 0, arr_len
- upos
);
19839 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19843 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19845 if (arr
[arr_pos
] != oldc
) continue;
19847 arr
[arr_pos
] = newc
;
19853 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19859 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19861 if (arr
[arr_pos
] == c
) continue;
19863 arr
[ret_len
] = arr
[arr_pos
];
19871 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19873 if (ulen
> arr_len
) return (arr_len
);
19875 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19879 memcpy (cs
, arr
, ulen
);
19883 for (i
= 0; i
< ulen
; i
++)
19887 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19893 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19895 if (ulen
> arr_len
) return (arr_len
);
19897 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19899 int upos
= arr_len
- ulen
;
19903 for (i
= 0; i
< ulen
; i
++)
19905 char c
= arr
[upos
+ i
];
19907 arr_len
= mangle_append (arr
, arr_len
, c
);
19913 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19915 if ( arr_len
== 0) return (arr_len
);
19916 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19918 char c
= arr
[upos
];
19922 for (i
= 0; i
< ulen
; i
++)
19924 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19930 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19932 if ( arr_len
== 0) return (arr_len
);
19933 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19937 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19939 int new_pos
= arr_pos
* 2;
19941 arr
[new_pos
] = arr
[arr_pos
];
19943 arr
[new_pos
+ 1] = arr
[arr_pos
];
19946 return (arr_len
* 2);
19949 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19951 if (upos
>= arr_len
) return (arr_len
);
19952 if (upos2
>= arr_len
) return (arr_len
);
19954 MANGLE_SWITCH (arr
, upos
, upos2
);
19959 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19961 MANGLE_SWITCH (arr
, upos
, upos2
);
19966 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19968 if (upos
>= arr_len
) return (arr_len
);
19975 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19977 if (upos
>= arr_len
) return (arr_len
);
19984 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19986 if (upos
>= arr_len
) return (arr_len
);
19993 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19995 if (upos
>= arr_len
) return (arr_len
);
20002 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20004 int upper_next
= 1;
20008 for (pos
= 0; pos
< arr_len
; pos
++)
20010 if (arr
[pos
] == ' ')
20021 MANGLE_UPPER_AT (arr
, pos
);
20025 MANGLE_LOWER_AT (arr
, pos
);
20032 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
20034 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20038 uint32_t rule_pos
= 0;
20040 for (j
= 0; j
< rp_gen_num
; j
++)
20047 switch ((char) get_random_num (0, 9))
20050 r
= get_random_num (0, sizeof (grp_op_nop
));
20051 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20055 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20056 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20057 p1
= get_random_num (0, sizeof (grp_pos
));
20058 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20062 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20063 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20064 p1
= get_random_num (1, 6);
20065 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20069 r
= get_random_num (0, sizeof (grp_op_chr
));
20070 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20071 p1
= get_random_num (0x20, 0x7e);
20072 rule_buf
[rule_pos
++] = (char) p1
;
20076 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20077 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20078 p1
= get_random_num (0x20, 0x7e);
20079 rule_buf
[rule_pos
++] = (char) p1
;
20080 p2
= get_random_num (0x20, 0x7e);
20082 p2
= get_random_num (0x20, 0x7e);
20083 rule_buf
[rule_pos
++] = (char) p2
;
20087 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20088 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20089 p1
= get_random_num (0, sizeof (grp_pos
));
20090 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20091 p2
= get_random_num (0x20, 0x7e);
20092 rule_buf
[rule_pos
++] = (char) p2
;
20096 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20097 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20098 p1
= get_random_num (0, sizeof (grp_pos
));
20099 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20100 p2
= get_random_num (0, sizeof (grp_pos
));
20102 p2
= get_random_num (0, sizeof (grp_pos
));
20103 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20107 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20108 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20109 p1
= get_random_num (0, sizeof (grp_pos
));
20110 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20111 p2
= get_random_num (1, sizeof (grp_pos
));
20113 p2
= get_random_num (1, sizeof (grp_pos
));
20114 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20118 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20119 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20120 p1
= get_random_num (0, sizeof (grp_pos
));
20121 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20122 p2
= get_random_num (1, sizeof (grp_pos
));
20123 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20124 p3
= get_random_num (0, sizeof (grp_pos
));
20125 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20133 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20135 char mem
[BLOCK_SIZE
];
20137 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20139 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20141 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20143 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20145 int out_len
= in_len
;
20146 int mem_len
= in_len
;
20148 memcpy (out
, in
, out_len
);
20152 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20154 int upos
; int upos2
;
20157 switch (rule
[rule_pos
])
20162 case RULE_OP_MANGLE_NOOP
:
20165 case RULE_OP_MANGLE_LREST
:
20166 out_len
= mangle_lrest (out
, out_len
);
20169 case RULE_OP_MANGLE_UREST
:
20170 out_len
= mangle_urest (out
, out_len
);
20173 case RULE_OP_MANGLE_LREST_UFIRST
:
20174 out_len
= mangle_lrest (out
, out_len
);
20175 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20178 case RULE_OP_MANGLE_UREST_LFIRST
:
20179 out_len
= mangle_urest (out
, out_len
);
20180 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20183 case RULE_OP_MANGLE_TREST
:
20184 out_len
= mangle_trest (out
, out_len
);
20187 case RULE_OP_MANGLE_TOGGLE_AT
:
20188 NEXT_RULEPOS (rule_pos
);
20189 NEXT_RPTOI (rule
, rule_pos
, upos
);
20190 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20193 case RULE_OP_MANGLE_REVERSE
:
20194 out_len
= mangle_reverse (out
, out_len
);
20197 case RULE_OP_MANGLE_DUPEWORD
:
20198 out_len
= mangle_double (out
, out_len
);
20201 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20202 NEXT_RULEPOS (rule_pos
);
20203 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20204 out_len
= mangle_double_times (out
, out_len
, ulen
);
20207 case RULE_OP_MANGLE_REFLECT
:
20208 out_len
= mangle_reflect (out
, out_len
);
20211 case RULE_OP_MANGLE_ROTATE_LEFT
:
20212 mangle_rotate_left (out
, out_len
);
20215 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20216 mangle_rotate_right (out
, out_len
);
20219 case RULE_OP_MANGLE_APPEND
:
20220 NEXT_RULEPOS (rule_pos
);
20221 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20224 case RULE_OP_MANGLE_PREPEND
:
20225 NEXT_RULEPOS (rule_pos
);
20226 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20229 case RULE_OP_MANGLE_DELETE_FIRST
:
20230 out_len
= mangle_delete_at (out
, out_len
, 0);
20233 case RULE_OP_MANGLE_DELETE_LAST
:
20234 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20237 case RULE_OP_MANGLE_DELETE_AT
:
20238 NEXT_RULEPOS (rule_pos
);
20239 NEXT_RPTOI (rule
, rule_pos
, upos
);
20240 out_len
= mangle_delete_at (out
, out_len
, upos
);
20243 case RULE_OP_MANGLE_EXTRACT
:
20244 NEXT_RULEPOS (rule_pos
);
20245 NEXT_RPTOI (rule
, rule_pos
, upos
);
20246 NEXT_RULEPOS (rule_pos
);
20247 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20248 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20251 case RULE_OP_MANGLE_OMIT
:
20252 NEXT_RULEPOS (rule_pos
);
20253 NEXT_RPTOI (rule
, rule_pos
, upos
);
20254 NEXT_RULEPOS (rule_pos
);
20255 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20256 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20259 case RULE_OP_MANGLE_INSERT
:
20260 NEXT_RULEPOS (rule_pos
);
20261 NEXT_RPTOI (rule
, rule_pos
, upos
);
20262 NEXT_RULEPOS (rule_pos
);
20263 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20266 case RULE_OP_MANGLE_OVERSTRIKE
:
20267 NEXT_RULEPOS (rule_pos
);
20268 NEXT_RPTOI (rule
, rule_pos
, upos
);
20269 NEXT_RULEPOS (rule_pos
);
20270 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20273 case RULE_OP_MANGLE_TRUNCATE_AT
:
20274 NEXT_RULEPOS (rule_pos
);
20275 NEXT_RPTOI (rule
, rule_pos
, upos
);
20276 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20279 case RULE_OP_MANGLE_REPLACE
:
20280 NEXT_RULEPOS (rule_pos
);
20281 NEXT_RULEPOS (rule_pos
);
20282 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20285 case RULE_OP_MANGLE_PURGECHAR
:
20286 NEXT_RULEPOS (rule_pos
);
20287 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20290 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20294 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20295 NEXT_RULEPOS (rule_pos
);
20296 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20297 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20300 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20301 NEXT_RULEPOS (rule_pos
);
20302 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20303 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20306 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20307 out_len
= mangle_dupechar (out
, out_len
);
20310 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20311 NEXT_RULEPOS (rule_pos
);
20312 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20313 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20316 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20317 NEXT_RULEPOS (rule_pos
);
20318 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20319 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20322 case RULE_OP_MANGLE_SWITCH_FIRST
:
20323 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20326 case RULE_OP_MANGLE_SWITCH_LAST
:
20327 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20330 case RULE_OP_MANGLE_SWITCH_AT
:
20331 NEXT_RULEPOS (rule_pos
);
20332 NEXT_RPTOI (rule
, rule_pos
, upos
);
20333 NEXT_RULEPOS (rule_pos
);
20334 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20335 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20338 case RULE_OP_MANGLE_CHR_SHIFTL
:
20339 NEXT_RULEPOS (rule_pos
);
20340 NEXT_RPTOI (rule
, rule_pos
, upos
);
20341 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20344 case RULE_OP_MANGLE_CHR_SHIFTR
:
20345 NEXT_RULEPOS (rule_pos
);
20346 NEXT_RPTOI (rule
, rule_pos
, upos
);
20347 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20350 case RULE_OP_MANGLE_CHR_INCR
:
20351 NEXT_RULEPOS (rule_pos
);
20352 NEXT_RPTOI (rule
, rule_pos
, upos
);
20353 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20356 case RULE_OP_MANGLE_CHR_DECR
:
20357 NEXT_RULEPOS (rule_pos
);
20358 NEXT_RPTOI (rule
, rule_pos
, upos
);
20359 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20362 case RULE_OP_MANGLE_REPLACE_NP1
:
20363 NEXT_RULEPOS (rule_pos
);
20364 NEXT_RPTOI (rule
, rule_pos
, upos
);
20365 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20368 case RULE_OP_MANGLE_REPLACE_NM1
:
20369 NEXT_RULEPOS (rule_pos
);
20370 NEXT_RPTOI (rule
, rule_pos
, upos
);
20371 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20374 case RULE_OP_MANGLE_TITLE
:
20375 out_len
= mangle_title (out
, out_len
);
20378 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20379 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20380 NEXT_RULEPOS (rule_pos
);
20381 NEXT_RPTOI (rule
, rule_pos
, upos
);
20382 NEXT_RULEPOS (rule_pos
);
20383 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20384 NEXT_RULEPOS (rule_pos
);
20385 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20386 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20389 case RULE_OP_MANGLE_APPEND_MEMORY
:
20390 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20391 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20392 memcpy (out
+ out_len
, mem
, mem_len
);
20393 out_len
+= mem_len
;
20396 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20397 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20398 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20399 memcpy (mem
+ mem_len
, out
, out_len
);
20400 out_len
+= mem_len
;
20401 memcpy (out
, mem
, out_len
);
20404 case RULE_OP_MEMORIZE_WORD
:
20405 memcpy (mem
, out
, out_len
);
20409 case RULE_OP_REJECT_LESS
:
20410 NEXT_RULEPOS (rule_pos
);
20411 NEXT_RPTOI (rule
, rule_pos
, upos
);
20412 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20415 case RULE_OP_REJECT_GREATER
:
20416 NEXT_RULEPOS (rule_pos
);
20417 NEXT_RPTOI (rule
, rule_pos
, upos
);
20418 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20421 case RULE_OP_REJECT_CONTAIN
:
20422 NEXT_RULEPOS (rule_pos
);
20423 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20426 case RULE_OP_REJECT_NOT_CONTAIN
:
20427 NEXT_RULEPOS (rule_pos
);
20428 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20431 case RULE_OP_REJECT_EQUAL_FIRST
:
20432 NEXT_RULEPOS (rule_pos
);
20433 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20436 case RULE_OP_REJECT_EQUAL_LAST
:
20437 NEXT_RULEPOS (rule_pos
);
20438 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20441 case RULE_OP_REJECT_EQUAL_AT
:
20442 NEXT_RULEPOS (rule_pos
);
20443 NEXT_RPTOI (rule
, rule_pos
, upos
);
20444 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20445 NEXT_RULEPOS (rule_pos
);
20446 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20449 case RULE_OP_REJECT_CONTAINS
:
20450 NEXT_RULEPOS (rule_pos
);
20451 NEXT_RPTOI (rule
, rule_pos
, upos
);
20452 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20453 NEXT_RULEPOS (rule_pos
);
20454 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20455 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20458 case RULE_OP_REJECT_MEMORY
:
20459 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20463 return (RULE_RC_SYNTAX_ERROR
);
20468 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);