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
.vendor_id
== VENDOR_ID_AMD
)
3067 if (data
.hm_device
[device_id
].od_version
== 5)
3069 ADLTemperature Temperature
;
3071 Temperature
.iSize
= sizeof (ADLTemperature
);
3073 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3075 return Temperature
.iTemperature
/ 1000;
3077 else if (data
.hm_device
[device_id
].od_version
== 6)
3079 int Temperature
= 0;
3081 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3083 return Temperature
/ 1000;
3088 if (data
.vendor_id
== VENDOR_ID_NV
)
3091 int temperature
= 0;
3093 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3099 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3101 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3102 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3103 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3104 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3106 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3108 return pThermalSettings
.sensor
[0].currentTemp
;
3115 int hm_get_fanspeed_with_device_id (const uint device_id
)
3117 if (data
.hm_device
[device_id
].fan_supported
== 1)
3119 if (data
.vendor_id
== VENDOR_ID_AMD
)
3123 if (data
.hm_device
[device_id
].od_version
== 5)
3125 ADLFanSpeedValue lpFanSpeedValue
;
3127 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3129 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3130 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3131 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3133 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3135 return lpFanSpeedValue
.iFanSpeed
;
3137 else // od_version == 6
3139 ADLOD6FanSpeedInfo faninfo
;
3141 memset (&faninfo
, 0, sizeof (faninfo
));
3143 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3145 return faninfo
.iFanSpeedPercent
;
3150 if (data
.vendor_id
== VENDOR_ID_NV
)
3155 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3163 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3173 int hm_get_utilization_with_device_id (const uint device_id
)
3175 if (data
.vendor_id
== VENDOR_ID_AMD
)
3179 ADLPMActivity PMActivity
;
3181 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3183 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3185 return PMActivity
.iActivityPercent
;
3189 if (data
.vendor_id
== VENDOR_ID_NV
)
3192 nvmlUtilization_t utilization
;
3194 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3196 return utilization
.gpu
;
3200 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3202 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3204 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3206 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3213 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3215 if (data
.hm_device
[device_id
].fan_supported
== 1)
3219 if (data
.hm_device
[device_id
].od_version
== 5)
3221 ADLFanSpeedValue lpFanSpeedValue
;
3223 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3225 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3226 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3227 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3228 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3230 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3234 else // od_version == 6
3236 ADLOD6FanSpeedValue fan_speed_value
;
3238 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3240 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3241 fan_speed_value
.iFanSpeed
= fanspeed
;
3243 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3257 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3259 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3261 if (css_cnt
> SP_PW_MAX
)
3263 log_error ("ERROR: mask length is too long");
3268 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3270 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3272 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3273 uint cs_len
= css
[css_pos
].cs_len
;
3275 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3277 uint c
= cs_buf
[cs_pos
] & 0xff;
3284 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3286 cs_t
*cs
= &css
[css_cnt
];
3288 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3290 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3292 memset (css_uniq
, 0, css_uniq_sz
);
3296 for (i
= 0; i
< cs
->cs_len
; i
++)
3298 const uint u
= cs
->cs_buf
[i
];
3303 for (i
= 0; i
< in_len
; i
++)
3305 uint u
= in_buf
[i
] & 0xff;
3307 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3309 if (css_uniq
[u
] == 1) continue;
3313 cs
->cs_buf
[cs
->cs_len
] = u
;
3321 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3325 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3327 uint p0
= in_buf
[in_pos
] & 0xff;
3329 if (interpret
== 1 && p0
== '?')
3333 if (in_pos
== in_len
) break;
3335 uint p1
= in_buf
[in_pos
] & 0xff;
3339 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3341 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3343 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3345 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3347 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3349 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3351 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3352 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3354 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3355 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3357 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3358 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3360 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3361 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3363 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3365 default: log_error ("Syntax error: %s", in_buf
);
3371 if (data
.hex_charset
)
3375 if (in_pos
== in_len
)
3377 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3382 uint p1
= in_buf
[in_pos
] & 0xff;
3384 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3386 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3393 chr
= hex_convert (p1
) << 0;
3394 chr
|= hex_convert (p0
) << 4;
3396 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3402 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3408 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3412 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3414 sum
*= css
[css_pos
].cs_len
;
3420 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3422 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3427 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3429 char p0
= mask_buf
[mask_pos
];
3435 if (mask_pos
== mask_len
) break;
3437 char p1
= mask_buf
[mask_pos
];
3443 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3445 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3447 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3449 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3451 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3453 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3455 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3456 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3458 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3459 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3461 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3462 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3464 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3465 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3467 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3469 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3475 if (data
.hex_charset
)
3479 // if there is no 2nd hex character, show an error:
3481 if (mask_pos
== mask_len
)
3483 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3488 char p1
= mask_buf
[mask_pos
];
3490 // if they are not valid hex character, show an error:
3492 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3494 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3501 chr
|= hex_convert (p1
) << 0;
3502 chr
|= hex_convert (p0
) << 4;
3504 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3517 log_error ("ERROR: invalid mask length (0)");
3527 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3529 for (int i
= 0; i
< css_cnt
; i
++)
3531 uint len
= css
[i
].cs_len
;
3532 uint64_t next
= val
/ len
;
3533 uint pos
= val
% len
;
3534 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3539 void mp_cut_at (char *mask
, uint max
)
3543 uint mask_len
= strlen (mask
);
3545 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3547 if (mask
[i
] == '?') i
++;
3553 void mp_setup_sys (cs_t
*mp_sys
)
3557 uint donec
[CHARSIZ
];
3559 memset (donec
, 0, sizeof (donec
));
3561 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3562 mp_sys
[0].cs_buf
[pos
++] = chr
;
3563 mp_sys
[0].cs_len
= pos
; }
3565 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3566 mp_sys
[1].cs_buf
[pos
++] = chr
;
3567 mp_sys
[1].cs_len
= pos
; }
3569 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3570 mp_sys
[2].cs_buf
[pos
++] = chr
;
3571 mp_sys
[2].cs_len
= pos
; }
3573 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3574 mp_sys
[3].cs_buf
[pos
++] = chr
;
3575 mp_sys
[3].cs_len
= pos
; }
3577 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3578 mp_sys
[4].cs_len
= pos
; }
3580 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3581 mp_sys
[5].cs_len
= pos
; }
3584 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3586 FILE *fp
= fopen (buf
, "rb");
3588 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3590 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3596 memset (mp_file
, 0, sizeof (mp_file
));
3598 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3602 len
= in_superchop (mp_file
);
3606 log_info ("WARNING: charset file corrupted");
3608 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3612 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3617 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3619 mp_usr
[index
].cs_len
= 0;
3621 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3624 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3626 char *new_mask_buf
= (char *) mymalloc (256);
3632 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3634 if (css_pos
== len
) break;
3636 char p0
= mask_buf
[mask_pos
];
3638 new_mask_buf
[mask_pos
] = p0
;
3644 if (mask_pos
== mask_len
) break;
3646 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3650 if (data
.hex_charset
)
3654 if (mask_pos
== mask_len
)
3656 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3661 char p1
= mask_buf
[mask_pos
];
3663 // if they are not valid hex character, show an error:
3665 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3667 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3672 new_mask_buf
[mask_pos
] = p1
;
3677 if (css_pos
== len
) return (new_mask_buf
);
3679 myfree (new_mask_buf
);
3688 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3694 for (i
= start
; i
< stop
; i
++)
3696 sum
*= root_css_buf
[i
].cs_len
;
3702 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3706 cs_t
*cs
= &root_css_buf
[start
];
3710 for (i
= start
; i
< stop
; i
++)
3712 const uint64_t m
= v
% cs
->cs_len
;
3713 const uint64_t d
= v
/ cs
->cs_len
;
3717 const uint k
= cs
->cs_buf
[m
];
3719 pw_buf
[i
- start
] = (char) k
;
3721 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3725 int sp_comp_val (const void *p1
, const void *p2
)
3727 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3728 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3730 return b2
->val
- b1
->val
;
3733 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3740 * Initialize hcstats
3743 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3745 uint64_t *root_stats_ptr
= root_stats_buf
;
3747 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3749 for (i
= 0; i
< SP_PW_MAX
; i
++)
3751 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3753 root_stats_ptr
+= CHARSIZ
;
3756 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3758 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3760 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3762 for (i
= 0; i
< SP_PW_MAX
; i
++)
3764 for (j
= 0; j
< CHARSIZ
; j
++)
3766 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3768 markov_stats_ptr
+= CHARSIZ
;
3778 char hcstat_tmp
[256];
3780 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3782 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3784 hcstat
= hcstat_tmp
;
3787 FILE *fd
= fopen (hcstat
, "rb");
3791 log_error ("%s: %s", hcstat
, strerror (errno
));
3796 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3798 log_error ("%s: Could not load data", hcstat
);
3803 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3805 log_error ("%s: Could not load data", hcstat
);
3813 * Markov modifier of hcstat_table on user request
3818 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3819 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3824 /* Add all stats to first position */
3826 for (i
= 1; i
< SP_PW_MAX
; i
++)
3828 uint64_t *out
= root_stats_buf_by_pos
[0];
3829 uint64_t *in
= root_stats_buf_by_pos
[i
];
3831 for (j
= 0; j
< CHARSIZ
; j
++)
3837 for (i
= 1; i
< SP_PW_MAX
; i
++)
3839 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3840 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3842 for (j
= 0; j
< CHARSIZ
; j
++)
3844 for (k
= 0; k
< CHARSIZ
; k
++)
3851 /* copy them to all pw_positions */
3853 for (i
= 1; i
< SP_PW_MAX
; i
++)
3855 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3858 for (i
= 1; i
< SP_PW_MAX
; i
++)
3860 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3868 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3870 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3872 for (i
= 0; i
< SP_PW_MAX
; i
++)
3874 root_table_buf_by_pos
[i
] = root_table_ptr
;
3876 root_table_ptr
+= CHARSIZ
;
3879 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3881 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3883 for (i
= 0; i
< SP_PW_MAX
; i
++)
3885 for (j
= 0; j
< CHARSIZ
; j
++)
3887 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3889 markov_table_ptr
+= CHARSIZ
;
3894 * Convert hcstat to tables
3897 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3899 uint key
= i
% CHARSIZ
;
3901 root_table_buf
[i
].key
= key
;
3902 root_table_buf
[i
].val
= root_stats_buf
[i
];
3905 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3907 uint key
= i
% CHARSIZ
;
3909 markov_table_buf
[i
].key
= key
;
3910 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3913 myfree (root_stats_buf
);
3914 myfree (markov_stats_buf
);
3920 for (i
= 0; i
< SP_PW_MAX
; i
++)
3922 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3925 for (i
= 0; i
< SP_PW_MAX
; i
++)
3927 for (j
= 0; j
< CHARSIZ
; j
++)
3929 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3934 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3937 * Convert tables to css
3940 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3942 uint pw_pos
= i
/ CHARSIZ
;
3944 cs_t
*cs
= &root_css_buf
[pw_pos
];
3946 if (cs
->cs_len
== threshold
) continue;
3948 uint key
= root_table_buf
[i
].key
;
3950 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3952 cs
->cs_buf
[cs
->cs_len
] = key
;
3958 * Convert table to css
3961 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3963 uint c
= i
/ CHARSIZ
;
3965 cs_t
*cs
= &markov_css_buf
[c
];
3967 if (cs
->cs_len
== threshold
) continue;
3969 uint pw_pos
= c
/ CHARSIZ
;
3971 uint key
= markov_table_buf
[i
].key
;
3973 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3975 cs
->cs_buf
[cs
->cs_len
] = key
;
3981 for (uint i = 0; i < 8; i++)
3983 for (uint j = 0x20; j < 0x80; j++)
3985 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
3987 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
3989 for (uint k = 0; k < 10; k++)
3991 printf (" %u\n", ptr->cs_buf[k]);
3998 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4000 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4002 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4012 for (uint j
= 1; j
< CHARSIZ
; j
++)
4022 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4024 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4026 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4028 out
+= CHARSIZ
* CHARSIZ
;
4029 in
+= CHARSIZ
* CHARSIZ
;
4031 for (uint j
= 0; j
< CHARSIZ
; j
++)
4038 for (uint k
= 1; k
< CHARSIZ
; k
++)
4050 * mixed shared functions
4053 void dump_hex (const char *s
, size_t size
)
4057 for (i
= 0; i
< size
; i
++)
4059 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4065 void usage_mini_print (const char *progname
)
4067 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4070 void usage_big_print (const char *progname
)
4072 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4075 char *get_exec_path ()
4077 int exec_path_len
= 1024;
4079 char *exec_path
= (char *) mymalloc (exec_path_len
);
4085 sprintf (tmp
, "/proc/%d/exe", getpid ());
4087 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4093 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4102 char *get_install_dir (const char *progname
)
4104 char *install_dir
= mystrdup (progname
);
4105 char *last_slash
= NULL
;
4107 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4111 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4117 install_dir
[0] = '.';
4121 return (install_dir
);
4124 char *get_profile_dir (const char *homedir
)
4126 #define DOT_HASHCAT ".hashcat"
4128 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4130 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4135 char *get_session_dir (const char *profile_dir
)
4137 #define SESSIONS_FOLDER "sessions"
4139 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4141 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4146 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4150 FILE *fd
= fopen (file
, "rb");
4154 log_error ("%s: %s", file
, strerror (errno
));
4159 #define MAX_KEY_SIZE (1024 * 1024)
4161 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4163 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4167 for (int fpos
= 0; fpos
< nread
; fpos
++)
4169 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4171 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4172 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4173 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4174 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4176 if (kpos
>= 64) kpos
= 0;
4184 void set_cpu_affinity (char *cpu_affinity
)
4187 DWORD_PTR aff_mask
= 0;
4198 char *devices
= strdup (cpu_affinity
);
4200 char *next
= strtok (devices
, ",");
4204 uint cpu_id
= atoi (next
);
4221 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4227 aff_mask
|= 1 << (cpu_id
- 1);
4231 CPU_SET ((cpu_id
- 1), &cpuset
);
4234 } while ((next
= strtok (NULL
, ",")) != NULL
);
4240 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4241 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4245 pthread_t thread
= pthread_self ();
4246 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4250 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4252 char *element
, *end
;
4254 end
= (char *) base
+ nmemb
* size
;
4256 for (element
= (char *) base
; element
< end
; element
+= size
)
4257 if (!compar (element
, key
))
4263 int sort_by_salt (const void *v1
, const void *v2
)
4265 const salt_t
*s1
= (const salt_t
*) v1
;
4266 const salt_t
*s2
= (const salt_t
*) v2
;
4268 const int res1
= s1
->salt_len
- s2
->salt_len
;
4270 if (res1
!= 0) return (res1
);
4272 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4274 if (res2
!= 0) return (res2
);
4282 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4283 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4290 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4291 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4297 int sort_by_salt_buf (const void *v1
, const void *v2
)
4299 const pot_t
*p1
= (const pot_t
*) v1
;
4300 const pot_t
*p2
= (const pot_t
*) v2
;
4302 const hash_t
*h1
= &p1
->hash
;
4303 const hash_t
*h2
= &p2
->hash
;
4305 const salt_t
*s1
= h1
->salt
;
4306 const salt_t
*s2
= h2
->salt
;
4312 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4313 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4319 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4321 const hash_t
*h1
= (const hash_t
*) v1
;
4322 const hash_t
*h2
= (const hash_t
*) v2
;
4324 const salt_t
*s1
= h1
->salt
;
4325 const salt_t
*s2
= h2
->salt
;
4327 // testphase: this should work
4332 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4333 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4336 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4337 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4338 if (s1->salt_len > s2->salt_len) return ( 1);
4339 if (s1->salt_len < s2->salt_len) return (-1);
4341 uint n = s1->salt_len;
4345 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4346 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4353 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4355 const hash_t
*h1
= (const hash_t
*) v1
;
4356 const hash_t
*h2
= (const hash_t
*) v2
;
4358 const salt_t
*s1
= h1
->salt
;
4359 const salt_t
*s2
= h2
->salt
;
4361 // 12 - 2 (since last 2 uints contain the digest)
4366 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4367 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4373 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4375 const hash_t
*h1
= (const hash_t
*) v1
;
4376 const hash_t
*h2
= (const hash_t
*) v2
;
4378 const void *d1
= h1
->digest
;
4379 const void *d2
= h2
->digest
;
4381 return data
.sort_by_digest (d1
, d2
);
4384 int sort_by_hash (const void *v1
, const void *v2
)
4386 const hash_t
*h1
= (const hash_t
*) v1
;
4387 const hash_t
*h2
= (const hash_t
*) v2
;
4391 const salt_t
*s1
= h1
->salt
;
4392 const salt_t
*s2
= h2
->salt
;
4394 int res
= sort_by_salt (s1
, s2
);
4396 if (res
!= 0) return (res
);
4399 const void *d1
= h1
->digest
;
4400 const void *d2
= h2
->digest
;
4402 return data
.sort_by_digest (d1
, d2
);
4405 int sort_by_pot (const void *v1
, const void *v2
)
4407 const pot_t
*p1
= (const pot_t
*) v1
;
4408 const pot_t
*p2
= (const pot_t
*) v2
;
4410 const hash_t
*h1
= &p1
->hash
;
4411 const hash_t
*h2
= &p2
->hash
;
4413 return sort_by_hash (h1
, h2
);
4416 int sort_by_mtime (const void *p1
, const void *p2
)
4418 const char **f1
= (const char **) p1
;
4419 const char **f2
= (const char **) p2
;
4421 struct stat s1
; stat (*f1
, &s1
);
4422 struct stat s2
; stat (*f2
, &s2
);
4424 return s2
.st_mtime
- s1
.st_mtime
;
4427 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4429 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4430 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4432 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4435 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4437 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4438 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4440 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4443 int sort_by_stringptr (const void *p1
, const void *p2
)
4445 const char **s1
= (const char **) p1
;
4446 const char **s2
= (const char **) p2
;
4448 return strcmp (*s1
, *s2
);
4451 int sort_by_dictstat (const void *s1
, const void *s2
)
4453 dictstat_t
*d1
= (dictstat_t
*) s1
;
4454 dictstat_t
*d2
= (dictstat_t
*) s2
;
4457 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4459 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4462 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4465 int sort_by_bitmap (const void *p1
, const void *p2
)
4467 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4468 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4470 return b1
->collisions
- b2
->collisions
;
4473 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4475 const uint32_t *d1
= (const uint32_t *) v1
;
4476 const uint32_t *d2
= (const uint32_t *) v2
;
4482 if (d1
[n
] > d2
[n
]) return ( 1);
4483 if (d1
[n
] < d2
[n
]) return (-1);
4489 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4491 const uint32_t *d1
= (const uint32_t *) v1
;
4492 const uint32_t *d2
= (const uint32_t *) v2
;
4498 if (d1
[n
] > d2
[n
]) return ( 1);
4499 if (d1
[n
] < d2
[n
]) return (-1);
4505 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4507 const uint32_t *d1
= (const uint32_t *) v1
;
4508 const uint32_t *d2
= (const uint32_t *) v2
;
4514 if (d1
[n
] > d2
[n
]) return ( 1);
4515 if (d1
[n
] < d2
[n
]) return (-1);
4521 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4523 const uint32_t *d1
= (const uint32_t *) v1
;
4524 const uint32_t *d2
= (const uint32_t *) v2
;
4530 if (d1
[n
] > d2
[n
]) return ( 1);
4531 if (d1
[n
] < d2
[n
]) return (-1);
4537 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4539 const uint32_t *d1
= (const uint32_t *) v1
;
4540 const uint32_t *d2
= (const uint32_t *) v2
;
4546 if (d1
[n
] > d2
[n
]) return ( 1);
4547 if (d1
[n
] < d2
[n
]) return (-1);
4553 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4555 const uint32_t *d1
= (const uint32_t *) v1
;
4556 const uint32_t *d2
= (const uint32_t *) v2
;
4562 if (d1
[n
] > d2
[n
]) return ( 1);
4563 if (d1
[n
] < d2
[n
]) return (-1);
4569 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4571 const uint32_t *d1
= (const uint32_t *) v1
;
4572 const uint32_t *d2
= (const uint32_t *) v2
;
4578 if (d1
[n
] > d2
[n
]) return ( 1);
4579 if (d1
[n
] < d2
[n
]) return (-1);
4585 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4587 const uint32_t *d1
= (const uint32_t *) v1
;
4588 const uint32_t *d2
= (const uint32_t *) v2
;
4594 if (d1
[n
] > d2
[n
]) return ( 1);
4595 if (d1
[n
] < d2
[n
]) return (-1);
4601 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4603 const uint64_t *d1
= (const uint64_t *) v1
;
4604 const uint64_t *d2
= (const uint64_t *) v2
;
4610 if (d1
[n
] > d2
[n
]) return ( 1);
4611 if (d1
[n
] < d2
[n
]) return (-1);
4617 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4619 const uint64_t *d1
= (const uint64_t *) v1
;
4620 const uint64_t *d2
= (const uint64_t *) v2
;
4626 if (d1
[n
] > d2
[n
]) return ( 1);
4627 if (d1
[n
] < d2
[n
]) return (-1);
4633 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4635 const uint64_t *d1
= (const uint64_t *) v1
;
4636 const uint64_t *d2
= (const uint64_t *) v2
;
4642 if (d1
[n
] > d2
[n
]) return ( 1);
4643 if (d1
[n
] < d2
[n
]) return (-1);
4649 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4651 const uint32_t *d1
= (const uint32_t *) v1
;
4652 const uint32_t *d2
= (const uint32_t *) v2
;
4654 const uint dgst_pos0
= data
.dgst_pos0
;
4655 const uint dgst_pos1
= data
.dgst_pos1
;
4656 const uint dgst_pos2
= data
.dgst_pos2
;
4657 const uint dgst_pos3
= data
.dgst_pos3
;
4659 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4660 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4661 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4662 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4663 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4664 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4665 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4666 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4671 void format_debug (char * debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4673 uint outfile_autohex
= data
.outfile_autohex
;
4675 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4677 FILE *debug_fp
= NULL
;
4679 if (debug_file
!= NULL
)
4681 debug_fp
= fopen (debug_file
, "ab");
4688 if (debug_fp
== NULL
)
4690 log_info ("WARNING: Could not open debug-file for writing");
4694 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4696 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4698 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4701 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4703 if (debug_mode
== 4)
4705 fputc (':', debug_fp
);
4707 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4710 fputc ('\n', debug_fp
);
4712 if (debug_file
!= NULL
) fclose (debug_fp
);
4716 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4718 int needs_hexify
= 0;
4720 if (outfile_autohex
== 1)
4722 for (uint i
= 0; i
< plain_len
; i
++)
4724 if (plain_ptr
[i
] < 0x20)
4731 if (plain_ptr
[i
] > 0x7f)
4740 if (needs_hexify
== 1)
4742 fprintf (fp
, "$HEX[");
4744 for (uint i
= 0; i
< plain_len
; i
++)
4746 fprintf (fp
, "%02x", plain_ptr
[i
]);
4753 fwrite (plain_ptr
, plain_len
, 1, fp
);
4757 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const uint64_t crackpos
, unsigned char *username
, const uint user_len
)
4759 uint outfile_format
= data
.outfile_format
;
4761 char separator
= data
.separator
;
4763 if (outfile_format
& OUTFILE_FMT_HASH
)
4765 fprintf (out_fp
, "%s", out_buf
);
4767 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4769 fputc (separator
, out_fp
);
4772 else if (data
.username
)
4774 if (username
!= NULL
)
4776 for (uint i
= 0; i
< user_len
; i
++)
4778 fprintf (out_fp
, "%c", username
[i
]);
4781 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4783 fputc (separator
, out_fp
);
4788 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4790 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4792 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4794 fputc (separator
, out_fp
);
4798 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4800 for (uint i
= 0; i
< plain_len
; i
++)
4802 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4805 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4807 fputc (separator
, out_fp
);
4811 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4814 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4819 fprintf (out_fp
, "%lu", crackpos
);
4821 fprintf (out_fp
, "%llu", crackpos
);
4826 fputc ('\n', out_fp
);
4829 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4833 pot_key
.hash
.salt
= hashes_buf
->salt
;
4834 pot_key
.hash
.digest
= hashes_buf
->digest
;
4836 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4842 input_buf
[input_len
] = 0;
4845 unsigned char *username
= NULL
;
4850 user_t
*user
= hashes_buf
->hash_info
->user
;
4854 username
= (unsigned char *) (user
->user_name
);
4856 user_len
= user
->user_len
;
4860 // do output the line
4861 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4865 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4866 #define LM_MASKED_PLAIN "[notfound]"
4868 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4874 pot_left_key
.hash
.salt
= hash_left
->salt
;
4875 pot_left_key
.hash
.digest
= hash_left
->digest
;
4877 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4881 uint weak_hash_found
= 0;
4883 pot_t pot_right_key
;
4885 pot_right_key
.hash
.salt
= hash_right
->salt
;
4886 pot_right_key
.hash
.digest
= hash_right
->digest
;
4888 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4890 if (pot_right_ptr
== NULL
)
4892 // special case, if "weak hash"
4894 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4896 weak_hash_found
= 1;
4898 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4900 // in theory this is not needed, but we are paranoia:
4902 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4903 pot_right_ptr
->plain_len
= 0;
4907 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4909 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
4914 // at least one half was found:
4918 input_buf
[input_len
] = 0;
4922 unsigned char *username
= NULL
;
4927 user_t
*user
= hash_left
->hash_info
->user
;
4931 username
= (unsigned char *) (user
->user_name
);
4933 user_len
= user
->user_len
;
4937 // mask the part which was not found
4939 uint left_part_masked
= 0;
4940 uint right_part_masked
= 0;
4942 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4944 if (pot_left_ptr
== NULL
)
4946 left_part_masked
= 1;
4948 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4950 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4952 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4953 pot_left_ptr
->plain_len
= mask_plain_len
;
4956 if (pot_right_ptr
== NULL
)
4958 right_part_masked
= 1;
4960 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4962 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4964 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4965 pot_right_ptr
->plain_len
= mask_plain_len
;
4968 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4972 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4974 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4976 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4978 // do output the line
4980 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4982 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4984 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4985 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4988 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4992 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4994 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4996 if (pot_ptr
== NULL
)
5000 input_buf
[input_len
] = 0;
5002 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5006 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5014 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5018 pot_t pot_right_key
;
5020 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5022 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5024 uint weak_hash_found
= 0;
5026 if (pot_right_ptr
== NULL
)
5028 // special case, if "weak hash"
5030 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5032 weak_hash_found
= 1;
5034 // we just need that pot_right_ptr is not a NULL pointer
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5040 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5042 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5047 // ... at least one part was not cracked
5051 input_buf
[input_len
] = 0;
5053 // only show the hash part which is still not cracked
5055 uint user_len
= input_len
- 32;
5057 char hash_output
[user_len
+ 33];
5059 memset (hash_output
, 0, sizeof (hash_output
));
5061 memcpy (hash_output
, input_buf
, input_len
);
5063 if (pot_left_ptr
!= NULL
)
5065 // only show right part (because left part was already found)
5067 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5069 hash_output
[user_len
+ 16] = 0;
5072 if (pot_right_ptr
!= NULL
)
5074 // only show left part (because right part was already found)
5076 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5078 hash_output
[user_len
+ 16] = 0;
5081 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5083 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5086 uint
devices_to_devicemask (char *opencl_devices
)
5088 uint opencl_devicemask
= 0;
5092 char *devices
= strdup (opencl_devices
);
5094 char *next
= strtok (devices
, ",");
5098 uint device_id
= atoi (next
);
5100 if (device_id
< 1 || device_id
> 8)
5102 log_error ("ERROR: invalid device_id %u specified", device_id
);
5107 opencl_devicemask
|= 1 << (device_id
- 1);
5109 } while ((next
= strtok (NULL
, ",")) != NULL
);
5114 return opencl_devicemask
;
5117 uint
get_random_num (uint min
, uint max
)
5119 if (min
== max
) return (min
);
5121 return (uint
) ((rand () % (max
- min
)) + min
);
5124 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5126 uint32_t quotient
= dividend
/ divisor
;
5128 if (dividend
% divisor
) quotient
++;
5133 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5135 uint64_t quotient
= dividend
/ divisor
;
5137 if (dividend
% divisor
) quotient
++;
5142 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5144 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5145 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5147 if (tm
->tm_year
- 70)
5149 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5150 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5152 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5154 else if (tm
->tm_yday
)
5156 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5157 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5159 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5161 else if (tm
->tm_hour
)
5163 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5164 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5166 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5168 else if (tm
->tm_min
)
5170 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5171 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5173 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5177 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5179 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5183 void format_speed_display (float val
, char *buf
, size_t len
)
5194 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5205 /* generate output */
5209 snprintf (buf
, len
- 1, "%.0f ", val
);
5213 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5217 void lowercase (char *buf
, int len
)
5219 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5222 void uppercase (char *buf
, int len
)
5224 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5227 int fgetl (FILE *fp
, char *line_buf
)
5233 const int c
= fgetc (fp
);
5235 if (c
== EOF
) break;
5237 line_buf
[line_len
] = (char) c
;
5241 if (line_len
== BUFSIZ
) line_len
--;
5243 if (c
== '\n') break;
5246 if (line_len
== 0) return 0;
5248 if (line_buf
[line_len
- 1] == '\n')
5252 line_buf
[line_len
] = 0;
5255 if (line_len
== 0) return 0;
5257 if (line_buf
[line_len
- 1] == '\r')
5261 line_buf
[line_len
] = 0;
5267 int in_superchop (char *buf
)
5269 int len
= strlen (buf
);
5273 if (buf
[len
- 1] == '\n')
5280 if (buf
[len
- 1] == '\r')
5295 char **scan_directory (const char *path
)
5297 char *tmp_path
= mystrdup (path
);
5299 size_t tmp_path_len
= strlen (tmp_path
);
5301 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5303 tmp_path
[tmp_path_len
- 1] = 0;
5305 tmp_path_len
= strlen (tmp_path
);
5308 char **files
= NULL
;
5314 if ((d
= opendir (tmp_path
)) != NULL
)
5318 while ((de
= readdir (d
)) != NULL
)
5320 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5322 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5324 char *path_file
= (char *) mymalloc (path_size
+ 1);
5326 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5328 path_file
[path_size
] = 0;
5332 if ((d_test
= opendir (path_file
)) != NULL
)
5340 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5344 files
[num_files
- 1] = path_file
;
5350 else if (errno
== ENOTDIR
)
5352 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5356 files
[num_files
- 1] = mystrdup (path
);
5359 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5363 files
[num_files
- 1] = NULL
;
5370 int count_dictionaries (char **dictionary_files
)
5372 if (dictionary_files
== NULL
) return 0;
5376 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5384 char *stroptitype (const uint opti_type
)
5388 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5389 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5390 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5391 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5392 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5393 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5394 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5395 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5396 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5397 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5398 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5399 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5400 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5401 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5407 char *strparser (const uint parser_status
)
5409 switch (parser_status
)
5411 case PARSER_OK
: return ((char *) PA_000
); break;
5412 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5413 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5414 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5415 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5416 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5417 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5418 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5419 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5420 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5421 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5422 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5423 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5424 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5425 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5426 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5427 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5430 return ((char *) PA_255
);
5433 char *strhashtype (const uint hash_mode
)
5437 case 0: return ((char *) HT_00000
); break;
5438 case 10: return ((char *) HT_00010
); break;
5439 case 11: return ((char *) HT_00011
); break;
5440 case 12: return ((char *) HT_00012
); break;
5441 case 20: return ((char *) HT_00020
); break;
5442 case 21: return ((char *) HT_00021
); break;
5443 case 22: return ((char *) HT_00022
); break;
5444 case 23: return ((char *) HT_00023
); break;
5445 case 30: return ((char *) HT_00030
); break;
5446 case 40: return ((char *) HT_00040
); break;
5447 case 50: return ((char *) HT_00050
); break;
5448 case 60: return ((char *) HT_00060
); break;
5449 case 100: return ((char *) HT_00100
); break;
5450 case 101: return ((char *) HT_00101
); break;
5451 case 110: return ((char *) HT_00110
); break;
5452 case 111: return ((char *) HT_00111
); break;
5453 case 112: return ((char *) HT_00112
); break;
5454 case 120: return ((char *) HT_00120
); break;
5455 case 121: return ((char *) HT_00121
); break;
5456 case 122: return ((char *) HT_00122
); break;
5457 case 124: return ((char *) HT_00124
); break;
5458 case 130: return ((char *) HT_00130
); break;
5459 case 131: return ((char *) HT_00131
); break;
5460 case 132: return ((char *) HT_00132
); break;
5461 case 133: return ((char *) HT_00133
); break;
5462 case 140: return ((char *) HT_00140
); break;
5463 case 141: return ((char *) HT_00141
); break;
5464 case 150: return ((char *) HT_00150
); break;
5465 case 160: return ((char *) HT_00160
); break;
5466 case 190: return ((char *) HT_00190
); break;
5467 case 200: return ((char *) HT_00200
); break;
5468 case 300: return ((char *) HT_00300
); break;
5469 case 400: return ((char *) HT_00400
); break;
5470 case 500: return ((char *) HT_00500
); break;
5471 case 501: return ((char *) HT_00501
); break;
5472 case 900: return ((char *) HT_00900
); break;
5473 case 910: return ((char *) HT_00910
); break;
5474 case 1000: return ((char *) HT_01000
); break;
5475 case 1100: return ((char *) HT_01100
); break;
5476 case 1400: return ((char *) HT_01400
); break;
5477 case 1410: return ((char *) HT_01410
); break;
5478 case 1420: return ((char *) HT_01420
); break;
5479 case 1421: return ((char *) HT_01421
); break;
5480 case 1430: return ((char *) HT_01430
); break;
5481 case 1440: return ((char *) HT_01440
); break;
5482 case 1441: return ((char *) HT_01441
); break;
5483 case 1450: return ((char *) HT_01450
); break;
5484 case 1460: return ((char *) HT_01460
); break;
5485 case 1500: return ((char *) HT_01500
); break;
5486 case 1600: return ((char *) HT_01600
); break;
5487 case 1700: return ((char *) HT_01700
); break;
5488 case 1710: return ((char *) HT_01710
); break;
5489 case 1711: return ((char *) HT_01711
); break;
5490 case 1720: return ((char *) HT_01720
); break;
5491 case 1722: return ((char *) HT_01722
); break;
5492 case 1730: return ((char *) HT_01730
); break;
5493 case 1731: return ((char *) HT_01731
); break;
5494 case 1740: return ((char *) HT_01740
); break;
5495 case 1750: return ((char *) HT_01750
); break;
5496 case 1760: return ((char *) HT_01760
); break;
5497 case 1800: return ((char *) HT_01800
); break;
5498 case 2100: return ((char *) HT_02100
); break;
5499 case 2400: return ((char *) HT_02400
); break;
5500 case 2410: return ((char *) HT_02410
); break;
5501 case 2500: return ((char *) HT_02500
); break;
5502 case 2600: return ((char *) HT_02600
); break;
5503 case 2611: return ((char *) HT_02611
); break;
5504 case 2612: return ((char *) HT_02612
); break;
5505 case 2711: return ((char *) HT_02711
); break;
5506 case 2811: return ((char *) HT_02811
); break;
5507 case 3000: return ((char *) HT_03000
); break;
5508 case 3100: return ((char *) HT_03100
); break;
5509 case 3200: return ((char *) HT_03200
); break;
5510 case 3710: return ((char *) HT_03710
); break;
5511 case 3711: return ((char *) HT_03711
); break;
5512 case 3800: return ((char *) HT_03800
); break;
5513 case 4300: return ((char *) HT_04300
); break;
5514 case 4400: return ((char *) HT_04400
); break;
5515 case 4500: return ((char *) HT_04500
); break;
5516 case 4700: return ((char *) HT_04700
); break;
5517 case 4800: return ((char *) HT_04800
); break;
5518 case 4900: return ((char *) HT_04900
); break;
5519 case 5000: return ((char *) HT_05000
); break;
5520 case 5100: return ((char *) HT_05100
); break;
5521 case 5200: return ((char *) HT_05200
); break;
5522 case 5300: return ((char *) HT_05300
); break;
5523 case 5400: return ((char *) HT_05400
); break;
5524 case 5500: return ((char *) HT_05500
); break;
5525 case 5600: return ((char *) HT_05600
); break;
5526 case 5700: return ((char *) HT_05700
); break;
5527 case 5800: return ((char *) HT_05800
); break;
5528 case 6000: return ((char *) HT_06000
); break;
5529 case 6100: return ((char *) HT_06100
); break;
5530 case 6211: return ((char *) HT_06211
); break;
5531 case 6212: return ((char *) HT_06212
); break;
5532 case 6213: return ((char *) HT_06213
); break;
5533 case 6221: return ((char *) HT_06221
); break;
5534 case 6222: return ((char *) HT_06222
); break;
5535 case 6223: return ((char *) HT_06223
); break;
5536 case 6231: return ((char *) HT_06231
); break;
5537 case 6232: return ((char *) HT_06232
); break;
5538 case 6233: return ((char *) HT_06233
); break;
5539 case 6241: return ((char *) HT_06241
); break;
5540 case 6242: return ((char *) HT_06242
); break;
5541 case 6243: return ((char *) HT_06243
); break;
5542 case 6300: return ((char *) HT_06300
); break;
5543 case 6400: return ((char *) HT_06400
); break;
5544 case 6500: return ((char *) HT_06500
); break;
5545 case 6600: return ((char *) HT_06600
); break;
5546 case 6700: return ((char *) HT_06700
); break;
5547 case 6800: return ((char *) HT_06800
); break;
5548 case 6900: return ((char *) HT_06900
); break;
5549 case 7100: return ((char *) HT_07100
); break;
5550 case 7200: return ((char *) HT_07200
); break;
5551 case 7300: return ((char *) HT_07300
); break;
5552 case 7400: return ((char *) HT_07400
); break;
5553 case 7500: return ((char *) HT_07500
); break;
5554 case 7600: return ((char *) HT_07600
); break;
5555 case 7700: return ((char *) HT_07700
); break;
5556 case 7800: return ((char *) HT_07800
); break;
5557 case 7900: return ((char *) HT_07900
); break;
5558 case 8000: return ((char *) HT_08000
); break;
5559 case 8100: return ((char *) HT_08100
); break;
5560 case 8200: return ((char *) HT_08200
); break;
5561 case 8300: return ((char *) HT_08300
); break;
5562 case 8400: return ((char *) HT_08400
); break;
5563 case 8500: return ((char *) HT_08500
); break;
5564 case 8600: return ((char *) HT_08600
); break;
5565 case 8700: return ((char *) HT_08700
); break;
5566 case 8800: return ((char *) HT_08800
); break;
5567 case 8900: return ((char *) HT_08900
); break;
5568 case 9000: return ((char *) HT_09000
); break;
5569 case 9100: return ((char *) HT_09100
); break;
5570 case 9200: return ((char *) HT_09200
); break;
5571 case 9300: return ((char *) HT_09300
); break;
5572 case 9400: return ((char *) HT_09400
); break;
5573 case 9500: return ((char *) HT_09500
); break;
5574 case 9600: return ((char *) HT_09600
); break;
5575 case 9700: return ((char *) HT_09700
); break;
5576 case 9710: return ((char *) HT_09710
); break;
5577 case 9720: return ((char *) HT_09720
); break;
5578 case 9800: return ((char *) HT_09800
); break;
5579 case 9810: return ((char *) HT_09810
); break;
5580 case 9820: return ((char *) HT_09820
); break;
5581 case 9900: return ((char *) HT_09900
); break;
5582 case 10000: return ((char *) HT_10000
); break;
5583 case 10100: return ((char *) HT_10100
); break;
5584 case 10200: return ((char *) HT_10200
); break;
5585 case 10300: return ((char *) HT_10300
); break;
5586 case 10400: return ((char *) HT_10400
); break;
5587 case 10410: return ((char *) HT_10410
); break;
5588 case 10420: return ((char *) HT_10420
); break;
5589 case 10500: return ((char *) HT_10500
); break;
5590 case 10600: return ((char *) HT_10600
); break;
5591 case 10700: return ((char *) HT_10700
); break;
5592 case 10800: return ((char *) HT_10800
); break;
5593 case 10900: return ((char *) HT_10900
); break;
5594 case 11000: return ((char *) HT_11000
); break;
5595 case 11100: return ((char *) HT_11100
); break;
5596 case 11200: return ((char *) HT_11200
); break;
5597 case 11300: return ((char *) HT_11300
); break;
5598 case 11400: return ((char *) HT_11400
); break;
5599 case 11500: return ((char *) HT_11500
); break;
5600 case 11600: return ((char *) HT_11600
); break;
5601 case 11700: return ((char *) HT_11700
); break;
5602 case 11800: return ((char *) HT_11800
); break;
5603 case 11900: return ((char *) HT_11900
); break;
5604 case 12000: return ((char *) HT_12000
); break;
5605 case 12100: return ((char *) HT_12100
); break;
5606 case 12200: return ((char *) HT_12200
); break;
5607 case 12300: return ((char *) HT_12300
); break;
5608 case 12400: return ((char *) HT_12400
); break;
5609 case 12500: return ((char *) HT_12500
); break;
5610 case 12600: return ((char *) HT_12600
); break;
5611 case 12700: return ((char *) HT_12700
); break;
5612 case 12800: return ((char *) HT_12800
); break;
5613 case 12900: return ((char *) HT_12900
); break;
5614 case 13000: return ((char *) HT_13000
); break;
5617 return ((char *) "Unknown");
5620 char *strstatus (const uint devices_status
)
5622 switch (devices_status
)
5624 case STATUS_INIT
: return ((char *) ST_0000
); break;
5625 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5626 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5627 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5628 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5629 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5630 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5631 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5632 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5633 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5636 return ((char *) "Unknown");
5639 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5641 uint hash_type
= data
.hash_type
;
5642 uint hash_mode
= data
.hash_mode
;
5643 uint salt_type
= data
.salt_type
;
5644 uint opts_type
= data
.opts_type
;
5645 uint opti_type
= data
.opti_type
;
5646 uint dgst_size
= data
.dgst_size
;
5648 char *hashfile
= data
.hashfile
;
5652 uint digest_buf
[64];
5654 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5656 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5658 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5660 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5666 case HASH_TYPE_DESCRYPT
:
5667 FP (digest_buf
[1], digest_buf
[0], tt
);
5670 case HASH_TYPE_DESRACF
:
5671 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5672 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5674 FP (digest_buf
[1], digest_buf
[0], tt
);
5678 FP (digest_buf
[1], digest_buf
[0], tt
);
5681 case HASH_TYPE_NETNTLM
:
5682 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5683 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5684 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5685 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5687 FP (digest_buf
[1], digest_buf
[0], tt
);
5688 FP (digest_buf
[3], digest_buf
[2], tt
);
5691 case HASH_TYPE_BSDICRYPT
:
5692 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5693 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5695 FP (digest_buf
[1], digest_buf
[0], tt
);
5700 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5705 digest_buf
[0] += MD4M_A
;
5706 digest_buf
[1] += MD4M_B
;
5707 digest_buf
[2] += MD4M_C
;
5708 digest_buf
[3] += MD4M_D
;
5712 digest_buf
[0] += MD5M_A
;
5713 digest_buf
[1] += MD5M_B
;
5714 digest_buf
[2] += MD5M_C
;
5715 digest_buf
[3] += MD5M_D
;
5718 case HASH_TYPE_SHA1
:
5719 digest_buf
[0] += SHA1M_A
;
5720 digest_buf
[1] += SHA1M_B
;
5721 digest_buf
[2] += SHA1M_C
;
5722 digest_buf
[3] += SHA1M_D
;
5723 digest_buf
[4] += SHA1M_E
;
5726 case HASH_TYPE_SHA256
:
5727 digest_buf
[0] += SHA256M_A
;
5728 digest_buf
[1] += SHA256M_B
;
5729 digest_buf
[2] += SHA256M_C
;
5730 digest_buf
[3] += SHA256M_D
;
5731 digest_buf
[4] += SHA256M_E
;
5732 digest_buf
[5] += SHA256M_F
;
5733 digest_buf
[6] += SHA256M_G
;
5734 digest_buf
[7] += SHA256M_H
;
5737 case HASH_TYPE_SHA384
:
5738 digest_buf64
[0] += SHA384M_A
;
5739 digest_buf64
[1] += SHA384M_B
;
5740 digest_buf64
[2] += SHA384M_C
;
5741 digest_buf64
[3] += SHA384M_D
;
5742 digest_buf64
[4] += SHA384M_E
;
5743 digest_buf64
[5] += SHA384M_F
;
5744 digest_buf64
[6] += 0;
5745 digest_buf64
[7] += 0;
5748 case HASH_TYPE_SHA512
:
5749 digest_buf64
[0] += SHA512M_A
;
5750 digest_buf64
[1] += SHA512M_B
;
5751 digest_buf64
[2] += SHA512M_C
;
5752 digest_buf64
[3] += SHA512M_D
;
5753 digest_buf64
[4] += SHA512M_E
;
5754 digest_buf64
[5] += SHA512M_F
;
5755 digest_buf64
[6] += SHA512M_G
;
5756 digest_buf64
[7] += SHA512M_H
;
5761 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5763 if (dgst_size
== DGST_SIZE_4_2
)
5765 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5767 else if (dgst_size
== DGST_SIZE_4_4
)
5769 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5771 else if (dgst_size
== DGST_SIZE_4_5
)
5773 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5775 else if (dgst_size
== DGST_SIZE_4_6
)
5777 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5779 else if (dgst_size
== DGST_SIZE_4_8
)
5781 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5783 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5785 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5787 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5789 else if (hash_type
== HASH_TYPE_SHA384
)
5791 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5793 else if (hash_type
== HASH_TYPE_SHA512
)
5795 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5797 else if (hash_type
== HASH_TYPE_GOST
)
5799 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5802 else if (dgst_size
== DGST_SIZE_4_64
)
5804 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5806 else if (dgst_size
== DGST_SIZE_8_25
)
5808 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5812 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5813 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5814 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5820 memset (&salt
, 0, sizeof (salt_t
));
5822 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5824 char *ptr
= (char *) salt
.salt_buf
;
5826 uint len
= salt
.salt_len
;
5828 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5834 case HASH_TYPE_NETNTLM
:
5836 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5837 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5839 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5845 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5847 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5855 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5857 uint max
= salt
.salt_len
/ 4;
5861 for (uint i
= 0; i
< max
; i
++)
5863 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5867 if (opts_type
& OPTS_TYPE_ST_HEX
)
5871 memset (tmp
, 0, sizeof (tmp
));
5873 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5875 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5880 memcpy (ptr
, tmp
, len
);
5883 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5885 memset (ptr
+ len
, 0, memset_size
);
5887 salt
.salt_len
= len
;
5891 // some modes require special encoding
5894 uint out_buf_plain
[256];
5895 uint out_buf_salt
[256];
5899 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5900 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5902 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5904 char *ptr_plain
= (char *) out_buf_plain
;
5905 char *ptr_salt
= (char *) out_buf_salt
;
5907 if (hash_mode
== 22)
5911 memset (username
, 0, sizeof (username
));
5913 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5915 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5917 uint16_t *ptr
= (uint16_t *) digest_buf
;
5919 tmp_buf
[ 0] = sig
[0];
5920 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5921 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5922 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5923 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5924 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5925 tmp_buf
[ 6] = sig
[1];
5926 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5927 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5928 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5929 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5930 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5931 tmp_buf
[12] = sig
[2];
5932 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5933 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5934 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5935 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5936 tmp_buf
[17] = sig
[3];
5937 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5938 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5939 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5940 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5941 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5942 tmp_buf
[23] = sig
[4];
5943 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5944 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5945 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5946 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5947 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5948 tmp_buf
[29] = sig
[5];
5950 snprintf (out_buf
, len
-1, "%s:%s",
5954 else if (hash_mode
== 23)
5956 // do not show the \nskyper\n part in output
5958 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5960 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5962 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5969 else if (hash_mode
== 101)
5971 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5973 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5974 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5975 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5976 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5977 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5979 memcpy (tmp_buf
, digest_buf
, 20);
5981 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5983 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5985 else if (hash_mode
== 111)
5987 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5989 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5990 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5991 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5992 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5993 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5995 memcpy (tmp_buf
, digest_buf
, 20);
5996 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5998 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
6000 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6002 else if (hash_mode
== 122)
6004 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6005 (unsigned char *) salt
.salt_buf
,
6012 else if (hash_mode
== 124)
6014 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6015 (unsigned char *) salt
.salt_buf
,
6022 else if (hash_mode
== 131)
6024 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6025 (unsigned char *) salt
.salt_buf
,
6033 else if (hash_mode
== 132)
6035 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6036 (unsigned char *) salt
.salt_buf
,
6043 else if (hash_mode
== 133)
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);
6055 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6057 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6059 else if (hash_mode
== 141)
6061 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6063 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6065 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6067 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6073 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6075 memcpy (tmp_buf
, digest_buf
, 20);
6077 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6081 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6083 else if (hash_mode
== 400)
6085 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6087 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6088 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6089 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6090 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6092 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6094 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6096 else if (hash_mode
== 500)
6098 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6100 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6101 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6102 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6103 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6105 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6107 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6109 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6113 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6116 else if (hash_mode
== 501)
6118 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6120 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6121 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6123 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6125 else if (hash_mode
== 1421)
6127 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6129 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6145 else if (hash_mode
== 1441)
6147 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6149 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6151 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6153 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6155 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6156 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6157 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6158 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6159 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6160 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6161 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6162 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6164 memcpy (tmp_buf
, digest_buf
, 32);
6166 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6170 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6172 else if (hash_mode
== 1500)
6174 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6175 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6176 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6177 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6178 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6180 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6182 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6184 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6185 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6187 memcpy (tmp_buf
, digest_buf
, 8);
6189 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6191 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6195 else if (hash_mode
== 1600)
6197 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6199 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6200 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6201 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6202 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6204 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6206 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6208 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6212 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6215 else if (hash_mode
== 1711)
6217 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6219 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6220 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6221 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6222 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6223 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6224 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6225 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6226 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6228 memcpy (tmp_buf
, digest_buf
, 64);
6229 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6231 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6233 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6235 else if (hash_mode
== 1722)
6237 uint
*ptr
= digest_buf
;
6239 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6240 (unsigned char *) salt
.salt_buf
,
6250 else if (hash_mode
== 1731)
6252 uint
*ptr
= digest_buf
;
6254 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6255 (unsigned char *) salt
.salt_buf
,
6265 else if (hash_mode
== 1800)
6269 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6270 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6271 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6272 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6273 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6274 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6275 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6276 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6278 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6280 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6282 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6286 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6289 else if (hash_mode
== 2100)
6293 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6295 salt
.salt_iter
+ 1);
6297 uint signature_len
= strlen (out_buf
);
6299 pos
+= signature_len
;
6300 len
-= signature_len
;
6302 char *salt_ptr
= (char *) salt
.salt_buf
;
6304 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6306 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6307 byte_swap_32 (digest_buf
[0]),
6308 byte_swap_32 (digest_buf
[1]),
6309 byte_swap_32 (digest_buf
[2]),
6310 byte_swap_32 (digest_buf
[3]));
6312 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6314 memcpy (tmp_buf
, digest_buf
, 16);
6316 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6318 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6319 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6320 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6321 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6323 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6324 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6325 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6326 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6328 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6329 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6330 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6331 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6333 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6334 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6335 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6336 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6338 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6339 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6340 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6341 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6345 else if (hash_mode
== 2500)
6347 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6349 wpa_t
*wpa
= &wpas
[salt_pos
];
6353 char *pke_ptr
= (char *) pke
;
6355 for (uint i
= 0; i
< 25; i
++)
6357 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6360 unsigned char mac1
[6];
6361 unsigned char mac2
[6];
6363 memcpy (mac1
, pke_ptr
+ 23, 6);
6364 memcpy (mac2
, pke_ptr
+ 29, 6);
6366 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6367 (char *) salt
.salt_buf
,
6381 else if (hash_mode
== 4400)
6383 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6384 byte_swap_32 (digest_buf
[0]),
6385 byte_swap_32 (digest_buf
[1]),
6386 byte_swap_32 (digest_buf
[2]),
6387 byte_swap_32 (digest_buf
[3]));
6389 else if (hash_mode
== 4700)
6391 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6392 byte_swap_32 (digest_buf
[0]),
6393 byte_swap_32 (digest_buf
[1]),
6394 byte_swap_32 (digest_buf
[2]),
6395 byte_swap_32 (digest_buf
[3]),
6396 byte_swap_32 (digest_buf
[4]));
6398 else if (hash_mode
== 4800)
6400 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6402 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6407 byte_swap_32 (salt
.salt_buf
[0]),
6408 byte_swap_32 (salt
.salt_buf
[1]),
6409 byte_swap_32 (salt
.salt_buf
[2]),
6410 byte_swap_32 (salt
.salt_buf
[3]),
6413 else if (hash_mode
== 4900)
6415 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6416 byte_swap_32 (digest_buf
[0]),
6417 byte_swap_32 (digest_buf
[1]),
6418 byte_swap_32 (digest_buf
[2]),
6419 byte_swap_32 (digest_buf
[3]),
6420 byte_swap_32 (digest_buf
[4]));
6422 else if (hash_mode
== 5100)
6424 snprintf (out_buf
, len
-1, "%08x%08x",
6428 else if (hash_mode
== 5200)
6430 snprintf (out_buf
, len
-1, "%s", hashfile
);
6432 else if (hash_mode
== 5300)
6434 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6436 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6438 int buf_len
= len
-1;
6442 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6444 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6446 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6448 snprintf (out_buf
, buf_len
, ":");
6454 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6462 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6464 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6466 if ((i
== 0) || (i
== 5))
6468 snprintf (out_buf
, buf_len
, ":");
6474 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6482 for (uint i
= 0; i
< 4; i
++)
6486 snprintf (out_buf
, buf_len
, ":");
6492 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6498 else if (hash_mode
== 5400)
6500 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6502 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6504 int buf_len
= len
-1;
6508 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6510 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6512 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6514 snprintf (out_buf
, buf_len
, ":");
6520 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6528 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6530 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6532 if ((i
== 0) || (i
== 5))
6534 snprintf (out_buf
, buf_len
, ":");
6540 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6548 for (uint i
= 0; i
< 5; i
++)
6552 snprintf (out_buf
, buf_len
, ":");
6558 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6564 else if (hash_mode
== 5500)
6566 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6568 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6571 char domain_buf
[64];
6572 char srvchall_buf
[1024];
6573 char clichall_buf
[1024];
6575 memset (user_buf
, 0, sizeof (user_buf
));
6576 memset (domain_buf
, 0, sizeof (domain_buf
));
6577 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6578 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6580 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6582 char *ptr
= (char *) netntlm
->userdomain_buf
;
6584 user_buf
[i
] = ptr
[j
];
6587 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6589 char *ptr
= (char *) netntlm
->userdomain_buf
;
6591 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6594 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6596 char *ptr
= (char *) netntlm
->chall_buf
;
6598 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6601 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6603 char *ptr
= (char *) netntlm
->chall_buf
;
6605 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6608 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6616 byte_swap_32 (salt
.salt_buf_pc
[0]),
6617 byte_swap_32 (salt
.salt_buf_pc
[1]),
6620 else if (hash_mode
== 5600)
6622 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6624 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6627 char domain_buf
[64];
6628 char srvchall_buf
[1024];
6629 char clichall_buf
[1024];
6631 memset (user_buf
, 0, sizeof (user_buf
));
6632 memset (domain_buf
, 0, sizeof (domain_buf
));
6633 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6634 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6636 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6638 char *ptr
= (char *) netntlm
->userdomain_buf
;
6640 user_buf
[i
] = ptr
[j
];
6643 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6645 char *ptr
= (char *) netntlm
->userdomain_buf
;
6647 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6650 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6652 char *ptr
= (char *) netntlm
->chall_buf
;
6654 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6657 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6659 char *ptr
= (char *) netntlm
->chall_buf
;
6661 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6664 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6674 else if (hash_mode
== 5700)
6676 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6678 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6679 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6680 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6681 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6682 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6683 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6684 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6685 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6687 memcpy (tmp_buf
, digest_buf
, 32);
6689 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6693 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6695 else if (hash_mode
== 5800)
6697 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6698 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6699 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6700 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6701 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6703 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6710 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6712 snprintf (out_buf
, len
-1, "%s", hashfile
);
6714 else if (hash_mode
== 6300)
6716 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6718 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6719 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6720 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6721 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6723 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6725 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6727 else if (hash_mode
== 6400)
6729 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6731 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6733 else if (hash_mode
== 6500)
6735 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6737 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6739 else if (hash_mode
== 6600)
6741 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6743 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6745 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6746 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6748 uint buf_len
= len
- 1;
6750 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6753 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6755 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6760 else if (hash_mode
== 6700)
6762 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6764 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6766 else if (hash_mode
== 6800)
6768 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6770 else if (hash_mode
== 7100)
6772 uint
*ptr
= digest_buf
;
6774 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6776 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6780 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6781 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6782 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6783 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6784 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6785 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6786 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6787 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6789 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",
6790 SIGNATURE_SHA512OSX
,
6792 esalt
[ 0], esalt
[ 1],
6793 esalt
[ 2], esalt
[ 3],
6794 esalt
[ 4], esalt
[ 5],
6795 esalt
[ 6], esalt
[ 7],
6803 ptr
[15], ptr
[14]);
6805 else if (hash_mode
== 7200)
6807 uint
*ptr
= digest_buf
;
6809 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6811 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6815 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6817 len_used
= strlen (out_buf
);
6819 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6821 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6823 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6826 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",
6834 ptr
[15], ptr
[14]);
6836 else if (hash_mode
== 7300)
6838 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6840 rakp_t
*rakp
= &rakps
[salt_pos
];
6842 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6844 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6847 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6854 else if (hash_mode
== 7400)
6856 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6858 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6859 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6860 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6861 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6862 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6863 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6864 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6865 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6867 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6869 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6871 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6875 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6878 else if (hash_mode
== 7500)
6880 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6882 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6884 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6885 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6889 char *ptr_data
= data
;
6891 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6893 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6896 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6898 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6903 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6905 (char *) krb5pa
->user
,
6906 (char *) krb5pa
->realm
,
6907 (char *) krb5pa
->salt
,
6910 else if (hash_mode
== 7700)
6912 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6913 (char *) salt
.salt_buf
,
6917 else if (hash_mode
== 7800)
6919 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6920 (char *) salt
.salt_buf
,
6927 else if (hash_mode
== 7900)
6929 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6933 char *tmp
= (char *) salt
.salt_buf_pc
;
6935 ptr_plain
[42] = tmp
[0];
6941 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6943 else if (hash_mode
== 8000)
6945 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6946 (unsigned char *) salt
.salt_buf
,
6956 else if (hash_mode
== 8100)
6958 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6959 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6961 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6962 (unsigned char *) salt
.salt_buf
,
6969 else if (hash_mode
== 8200)
6971 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6973 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6975 char data_buf
[4096];
6977 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6979 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6982 data_buf
[cloudkey
->data_len
* 2] = 0;
6984 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6985 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6986 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6987 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6988 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6989 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6990 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6991 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6993 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6994 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6995 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6996 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6998 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7014 else if (hash_mode
== 8300)
7018 char digest_buf_c
[33];
7020 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
7022 digest_buf_c
[32] = 0;
7026 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7028 char domain_buf_c
[33];
7030 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7032 for (uint i
= 0; i
< salt_pc_len
; i
++)
7034 const char next
= domain_buf_c
[i
];
7036 domain_buf_c
[i
] = '.';
7041 domain_buf_c
[salt_pc_len
] = 0;
7045 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7047 else if (hash_mode
== 8500)
7049 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7051 else if (hash_mode
== 2612)
7053 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7055 (char *) salt
.salt_buf
,
7061 else if (hash_mode
== 3711)
7063 char *salt_ptr
= (char *) salt
.salt_buf
;
7065 salt_ptr
[salt
.salt_len
- 1] = 0;
7067 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7068 SIGNATURE_MEDIAWIKI_B
,
7075 else if (hash_mode
== 8800)
7077 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7079 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7083 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7085 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7090 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7091 SIGNATURE_ANDROIDFDE
,
7092 byte_swap_32 (salt
.salt_buf
[0]),
7093 byte_swap_32 (salt
.salt_buf
[1]),
7094 byte_swap_32 (salt
.salt_buf
[2]),
7095 byte_swap_32 (salt
.salt_buf
[3]),
7096 byte_swap_32 (digest_buf
[0]),
7097 byte_swap_32 (digest_buf
[1]),
7098 byte_swap_32 (digest_buf
[2]),
7099 byte_swap_32 (digest_buf
[3]),
7102 else if (hash_mode
== 8900)
7104 uint N
= salt
.scrypt_N
;
7105 uint r
= salt
.scrypt_r
;
7106 uint p
= salt
.scrypt_p
;
7108 char base64_salt
[32];
7110 memset (base64_salt
, 0, 32);
7112 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7114 memset (tmp_buf
, 0, 46);
7116 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7117 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7118 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7119 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7120 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7121 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7122 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7123 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7124 digest_buf
[8] = 0; // needed for base64_encode ()
7126 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7128 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7136 else if (hash_mode
== 9000)
7138 snprintf (out_buf
, len
-1, "%s", hashfile
);
7140 else if (hash_mode
== 9200)
7144 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7146 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7148 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7152 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7153 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7154 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7155 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7156 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7157 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7158 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7159 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7160 digest_buf
[8] = 0; // needed for base64_encode ()
7163 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7165 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7166 tmp_buf
[43] = 0; // cut it here
7170 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7172 else if (hash_mode
== 9300)
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 ()
7185 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7187 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7188 tmp_buf
[43] = 0; // cut it here
7190 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7192 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7194 else if (hash_mode
== 9400)
7196 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7198 office2007_t
*office2007
= &office2007s
[salt_pos
];
7200 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7201 SIGNATURE_OFFICE2007
,
7204 office2007
->keySize
,
7210 office2007
->encryptedVerifier
[0],
7211 office2007
->encryptedVerifier
[1],
7212 office2007
->encryptedVerifier
[2],
7213 office2007
->encryptedVerifier
[3],
7214 office2007
->encryptedVerifierHash
[0],
7215 office2007
->encryptedVerifierHash
[1],
7216 office2007
->encryptedVerifierHash
[2],
7217 office2007
->encryptedVerifierHash
[3],
7218 office2007
->encryptedVerifierHash
[4]);
7220 else if (hash_mode
== 9500)
7222 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7224 office2010_t
*office2010
= &office2010s
[salt_pos
];
7226 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,
7232 office2010
->encryptedVerifier
[0],
7233 office2010
->encryptedVerifier
[1],
7234 office2010
->encryptedVerifier
[2],
7235 office2010
->encryptedVerifier
[3],
7236 office2010
->encryptedVerifierHash
[0],
7237 office2010
->encryptedVerifierHash
[1],
7238 office2010
->encryptedVerifierHash
[2],
7239 office2010
->encryptedVerifierHash
[3],
7240 office2010
->encryptedVerifierHash
[4],
7241 office2010
->encryptedVerifierHash
[5],
7242 office2010
->encryptedVerifierHash
[6],
7243 office2010
->encryptedVerifierHash
[7]);
7245 else if (hash_mode
== 9600)
7247 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7249 office2013_t
*office2013
= &office2013s
[salt_pos
];
7251 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,
7257 office2013
->encryptedVerifier
[0],
7258 office2013
->encryptedVerifier
[1],
7259 office2013
->encryptedVerifier
[2],
7260 office2013
->encryptedVerifier
[3],
7261 office2013
->encryptedVerifierHash
[0],
7262 office2013
->encryptedVerifierHash
[1],
7263 office2013
->encryptedVerifierHash
[2],
7264 office2013
->encryptedVerifierHash
[3],
7265 office2013
->encryptedVerifierHash
[4],
7266 office2013
->encryptedVerifierHash
[5],
7267 office2013
->encryptedVerifierHash
[6],
7268 office2013
->encryptedVerifierHash
[7]);
7270 else if (hash_mode
== 9700)
7272 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7274 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7276 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7277 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7278 byte_swap_32 (salt
.salt_buf
[0]),
7279 byte_swap_32 (salt
.salt_buf
[1]),
7280 byte_swap_32 (salt
.salt_buf
[2]),
7281 byte_swap_32 (salt
.salt_buf
[3]),
7282 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7283 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7284 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7285 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7286 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7287 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7288 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7289 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7291 else if (hash_mode
== 9710)
7293 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7295 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7297 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7298 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7299 byte_swap_32 (salt
.salt_buf
[0]),
7300 byte_swap_32 (salt
.salt_buf
[1]),
7301 byte_swap_32 (salt
.salt_buf
[2]),
7302 byte_swap_32 (salt
.salt_buf
[3]),
7303 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7304 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7305 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7306 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7307 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7308 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7309 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7310 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7312 else if (hash_mode
== 9720)
7314 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7316 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7318 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7320 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7321 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7322 byte_swap_32 (salt
.salt_buf
[0]),
7323 byte_swap_32 (salt
.salt_buf
[1]),
7324 byte_swap_32 (salt
.salt_buf
[2]),
7325 byte_swap_32 (salt
.salt_buf
[3]),
7326 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7327 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7328 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7329 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7330 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7331 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7332 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7333 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7340 else if (hash_mode
== 9800)
7342 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7344 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7346 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7347 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7352 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7353 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7354 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7355 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7356 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7357 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7358 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7359 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7360 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7362 else if (hash_mode
== 9810)
7364 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7366 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7368 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7369 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7374 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7375 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7376 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7377 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7378 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7379 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7380 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7381 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7382 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7384 else if (hash_mode
== 9820)
7386 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7388 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7390 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7392 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7393 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7398 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7399 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7400 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7401 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7402 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7403 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7404 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7405 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7406 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7413 else if (hash_mode
== 10000)
7417 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7419 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7421 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7425 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7426 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7427 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7428 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7429 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7430 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7431 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7432 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7433 digest_buf
[8] = 0; // needed for base64_encode ()
7436 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7438 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7442 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7444 else if (hash_mode
== 10100)
7446 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7451 byte_swap_32 (salt
.salt_buf
[0]),
7452 byte_swap_32 (salt
.salt_buf
[1]),
7453 byte_swap_32 (salt
.salt_buf
[2]),
7454 byte_swap_32 (salt
.salt_buf
[3]));
7456 else if (hash_mode
== 10200)
7458 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7460 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7464 char challenge
[100];
7466 memset (challenge
, 0, sizeof (challenge
));
7468 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7474 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7475 (char *) cram_md5
->user
,
7483 memset (response
, 0, sizeof (response
));
7485 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7487 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7489 else if (hash_mode
== 10300)
7493 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7495 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7496 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7498 uint tmp_len
= 20 + salt
.salt_len
;
7502 char base64_encoded
[100];
7504 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7506 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7508 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7510 else if (hash_mode
== 10400)
7512 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7514 pdf_t
*pdf
= &pdfs
[salt_pos
];
7516 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",
7524 byte_swap_32 (pdf
->id_buf
[0]),
7525 byte_swap_32 (pdf
->id_buf
[1]),
7526 byte_swap_32 (pdf
->id_buf
[2]),
7527 byte_swap_32 (pdf
->id_buf
[3]),
7529 byte_swap_32 (pdf
->u_buf
[0]),
7530 byte_swap_32 (pdf
->u_buf
[1]),
7531 byte_swap_32 (pdf
->u_buf
[2]),
7532 byte_swap_32 (pdf
->u_buf
[3]),
7533 byte_swap_32 (pdf
->u_buf
[4]),
7534 byte_swap_32 (pdf
->u_buf
[5]),
7535 byte_swap_32 (pdf
->u_buf
[6]),
7536 byte_swap_32 (pdf
->u_buf
[7]),
7538 byte_swap_32 (pdf
->o_buf
[0]),
7539 byte_swap_32 (pdf
->o_buf
[1]),
7540 byte_swap_32 (pdf
->o_buf
[2]),
7541 byte_swap_32 (pdf
->o_buf
[3]),
7542 byte_swap_32 (pdf
->o_buf
[4]),
7543 byte_swap_32 (pdf
->o_buf
[5]),
7544 byte_swap_32 (pdf
->o_buf
[6]),
7545 byte_swap_32 (pdf
->o_buf
[7])
7548 else if (hash_mode
== 10410)
7550 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7552 pdf_t
*pdf
= &pdfs
[salt_pos
];
7554 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",
7562 byte_swap_32 (pdf
->id_buf
[0]),
7563 byte_swap_32 (pdf
->id_buf
[1]),
7564 byte_swap_32 (pdf
->id_buf
[2]),
7565 byte_swap_32 (pdf
->id_buf
[3]),
7567 byte_swap_32 (pdf
->u_buf
[0]),
7568 byte_swap_32 (pdf
->u_buf
[1]),
7569 byte_swap_32 (pdf
->u_buf
[2]),
7570 byte_swap_32 (pdf
->u_buf
[3]),
7571 byte_swap_32 (pdf
->u_buf
[4]),
7572 byte_swap_32 (pdf
->u_buf
[5]),
7573 byte_swap_32 (pdf
->u_buf
[6]),
7574 byte_swap_32 (pdf
->u_buf
[7]),
7576 byte_swap_32 (pdf
->o_buf
[0]),
7577 byte_swap_32 (pdf
->o_buf
[1]),
7578 byte_swap_32 (pdf
->o_buf
[2]),
7579 byte_swap_32 (pdf
->o_buf
[3]),
7580 byte_swap_32 (pdf
->o_buf
[4]),
7581 byte_swap_32 (pdf
->o_buf
[5]),
7582 byte_swap_32 (pdf
->o_buf
[6]),
7583 byte_swap_32 (pdf
->o_buf
[7])
7586 else if (hash_mode
== 10420)
7588 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7590 pdf_t
*pdf
= &pdfs
[salt_pos
];
7592 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7594 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",
7602 byte_swap_32 (pdf
->id_buf
[0]),
7603 byte_swap_32 (pdf
->id_buf
[1]),
7604 byte_swap_32 (pdf
->id_buf
[2]),
7605 byte_swap_32 (pdf
->id_buf
[3]),
7607 byte_swap_32 (pdf
->u_buf
[0]),
7608 byte_swap_32 (pdf
->u_buf
[1]),
7609 byte_swap_32 (pdf
->u_buf
[2]),
7610 byte_swap_32 (pdf
->u_buf
[3]),
7611 byte_swap_32 (pdf
->u_buf
[4]),
7612 byte_swap_32 (pdf
->u_buf
[5]),
7613 byte_swap_32 (pdf
->u_buf
[6]),
7614 byte_swap_32 (pdf
->u_buf
[7]),
7616 byte_swap_32 (pdf
->o_buf
[0]),
7617 byte_swap_32 (pdf
->o_buf
[1]),
7618 byte_swap_32 (pdf
->o_buf
[2]),
7619 byte_swap_32 (pdf
->o_buf
[3]),
7620 byte_swap_32 (pdf
->o_buf
[4]),
7621 byte_swap_32 (pdf
->o_buf
[5]),
7622 byte_swap_32 (pdf
->o_buf
[6]),
7623 byte_swap_32 (pdf
->o_buf
[7]),
7631 else if (hash_mode
== 10500)
7633 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7635 pdf_t
*pdf
= &pdfs
[salt_pos
];
7637 if (pdf
->id_len
== 32)
7639 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",
7647 byte_swap_32 (pdf
->id_buf
[0]),
7648 byte_swap_32 (pdf
->id_buf
[1]),
7649 byte_swap_32 (pdf
->id_buf
[2]),
7650 byte_swap_32 (pdf
->id_buf
[3]),
7651 byte_swap_32 (pdf
->id_buf
[4]),
7652 byte_swap_32 (pdf
->id_buf
[5]),
7653 byte_swap_32 (pdf
->id_buf
[6]),
7654 byte_swap_32 (pdf
->id_buf
[7]),
7656 byte_swap_32 (pdf
->u_buf
[0]),
7657 byte_swap_32 (pdf
->u_buf
[1]),
7658 byte_swap_32 (pdf
->u_buf
[2]),
7659 byte_swap_32 (pdf
->u_buf
[3]),
7660 byte_swap_32 (pdf
->u_buf
[4]),
7661 byte_swap_32 (pdf
->u_buf
[5]),
7662 byte_swap_32 (pdf
->u_buf
[6]),
7663 byte_swap_32 (pdf
->u_buf
[7]),
7665 byte_swap_32 (pdf
->o_buf
[0]),
7666 byte_swap_32 (pdf
->o_buf
[1]),
7667 byte_swap_32 (pdf
->o_buf
[2]),
7668 byte_swap_32 (pdf
->o_buf
[3]),
7669 byte_swap_32 (pdf
->o_buf
[4]),
7670 byte_swap_32 (pdf
->o_buf
[5]),
7671 byte_swap_32 (pdf
->o_buf
[6]),
7672 byte_swap_32 (pdf
->o_buf
[7])
7677 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",
7685 byte_swap_32 (pdf
->id_buf
[0]),
7686 byte_swap_32 (pdf
->id_buf
[1]),
7687 byte_swap_32 (pdf
->id_buf
[2]),
7688 byte_swap_32 (pdf
->id_buf
[3]),
7690 byte_swap_32 (pdf
->u_buf
[0]),
7691 byte_swap_32 (pdf
->u_buf
[1]),
7692 byte_swap_32 (pdf
->u_buf
[2]),
7693 byte_swap_32 (pdf
->u_buf
[3]),
7694 byte_swap_32 (pdf
->u_buf
[4]),
7695 byte_swap_32 (pdf
->u_buf
[5]),
7696 byte_swap_32 (pdf
->u_buf
[6]),
7697 byte_swap_32 (pdf
->u_buf
[7]),
7699 byte_swap_32 (pdf
->o_buf
[0]),
7700 byte_swap_32 (pdf
->o_buf
[1]),
7701 byte_swap_32 (pdf
->o_buf
[2]),
7702 byte_swap_32 (pdf
->o_buf
[3]),
7703 byte_swap_32 (pdf
->o_buf
[4]),
7704 byte_swap_32 (pdf
->o_buf
[5]),
7705 byte_swap_32 (pdf
->o_buf
[6]),
7706 byte_swap_32 (pdf
->o_buf
[7])
7710 else if (hash_mode
== 10600)
7712 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7714 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7715 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7717 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7719 else if (hash_mode
== 10700)
7721 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7723 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7724 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7726 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7728 else if (hash_mode
== 10900)
7730 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7732 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7733 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7735 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7737 else if (hash_mode
== 11100)
7739 uint32_t salt_challenge
= salt
.salt_buf
[0];
7741 salt_challenge
= byte_swap_32 (salt_challenge
);
7743 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7745 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7746 SIGNATURE_POSTGRESQL_AUTH
,
7754 else if (hash_mode
== 11200)
7756 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7757 SIGNATURE_MYSQL_AUTH
,
7758 (unsigned char *) salt
.salt_buf
,
7765 else if (hash_mode
== 11300)
7767 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7769 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7771 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7772 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7773 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7775 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7776 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7777 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7779 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7781 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7783 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7786 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7788 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7790 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7793 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7795 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7797 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7800 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7801 SIGNATURE_BITCOIN_WALLET
,
7805 (unsigned char *) salt
.salt_buf
,
7813 free (cry_master_buf
);
7815 free (public_key_buf
);
7817 else if (hash_mode
== 11400)
7819 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7821 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7822 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7824 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7826 else if (hash_mode
== 11600)
7828 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7830 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7832 const uint data_len
= seven_zip
->data_len
;
7834 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7836 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7838 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7840 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7843 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7844 SIGNATURE_SEVEN_ZIP
,
7848 (char *) seven_zip
->salt_buf
,
7850 seven_zip
->iv_buf
[0],
7851 seven_zip
->iv_buf
[1],
7852 seven_zip
->iv_buf
[2],
7853 seven_zip
->iv_buf
[3],
7855 seven_zip
->data_len
,
7856 seven_zip
->unpack_size
,
7861 else if (hash_mode
== 11700)
7863 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7873 else if (hash_mode
== 11800)
7875 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7893 else if (hash_mode
== 11900)
7895 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7897 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7898 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7900 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7902 else if (hash_mode
== 12000)
7904 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7906 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7907 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7909 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7911 else if (hash_mode
== 12100)
7913 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7915 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7916 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7918 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7920 else if (hash_mode
== 12200)
7922 uint
*ptr_digest
= digest_buf
;
7923 uint
*ptr_salt
= salt
.salt_buf
;
7925 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7932 else if (hash_mode
== 12300)
7934 uint
*ptr_digest
= digest_buf
;
7935 uint
*ptr_salt
= salt
.salt_buf
;
7937 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",
7938 ptr_digest
[ 0], ptr_digest
[ 1],
7939 ptr_digest
[ 2], ptr_digest
[ 3],
7940 ptr_digest
[ 4], ptr_digest
[ 5],
7941 ptr_digest
[ 6], ptr_digest
[ 7],
7942 ptr_digest
[ 8], ptr_digest
[ 9],
7943 ptr_digest
[10], ptr_digest
[11],
7944 ptr_digest
[12], ptr_digest
[13],
7945 ptr_digest
[14], ptr_digest
[15],
7951 else if (hash_mode
== 12400)
7953 // encode iteration count
7957 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7958 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7959 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7960 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7965 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7966 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7967 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7968 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7973 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7975 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7976 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7978 memcpy (tmp_buf
, digest_buf
, 8);
7980 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7984 // fill the resulting buffer
7986 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7988 else if (hash_mode
== 12500)
7990 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7992 byte_swap_32 (salt
.salt_buf
[0]),
7993 byte_swap_32 (salt
.salt_buf
[1]),
7999 else if (hash_mode
== 12600)
8001 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8002 digest_buf
[0] + salt
.salt_buf_pc
[0],
8003 digest_buf
[1] + salt
.salt_buf_pc
[1],
8004 digest_buf
[2] + salt
.salt_buf_pc
[2],
8005 digest_buf
[3] + salt
.salt_buf_pc
[3],
8006 digest_buf
[4] + salt
.salt_buf_pc
[4],
8007 digest_buf
[5] + salt
.salt_buf_pc
[5],
8008 digest_buf
[6] + salt
.salt_buf_pc
[6],
8009 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8011 else if (hash_mode
== 12700)
8013 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8015 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8016 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8018 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8020 else if (hash_mode
== 12800)
8022 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
8024 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",
8037 byte_swap_32 (digest_buf
[0]),
8038 byte_swap_32 (digest_buf
[1]),
8039 byte_swap_32 (digest_buf
[2]),
8040 byte_swap_32 (digest_buf
[3]),
8041 byte_swap_32 (digest_buf
[4]),
8042 byte_swap_32 (digest_buf
[5]),
8043 byte_swap_32 (digest_buf
[6]),
8044 byte_swap_32 (digest_buf
[7])
8047 else if (hash_mode
== 12900)
8049 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",
8058 byte_swap_32 (digest_buf
[0]),
8059 byte_swap_32 (digest_buf
[1]),
8060 byte_swap_32 (digest_buf
[2]),
8061 byte_swap_32 (digest_buf
[3]),
8062 byte_swap_32 (digest_buf
[4]),
8063 byte_swap_32 (digest_buf
[5]),
8064 byte_swap_32 (digest_buf
[6]),
8065 byte_swap_32 (digest_buf
[7]),
8072 else if (hash_mode
== 13000)
8074 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8076 rar5_t
*rar5
= &rar5s
[salt_pos
];
8078 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8088 byte_swap_32 (digest_buf
[0]),
8089 byte_swap_32 (digest_buf
[1])
8094 if (hash_type
== HASH_TYPE_MD4
)
8096 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8102 else if (hash_type
== HASH_TYPE_MD5
)
8104 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8110 else if (hash_type
== HASH_TYPE_SHA1
)
8112 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8119 else if (hash_type
== HASH_TYPE_SHA256
)
8121 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8131 else if (hash_type
== HASH_TYPE_SHA384
)
8133 uint
*ptr
= digest_buf
;
8135 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8143 else if (hash_type
== HASH_TYPE_SHA512
)
8145 uint
*ptr
= digest_buf
;
8147 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8157 else if (hash_type
== HASH_TYPE_LM
)
8159 snprintf (out_buf
, len
-1, "%08x%08x",
8163 else if (hash_type
== HASH_TYPE_ORACLEH
)
8165 snprintf (out_buf
, len
-1, "%08X%08X",
8169 else if (hash_type
== HASH_TYPE_BCRYPT
)
8171 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8172 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8174 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8176 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8178 else if (hash_type
== HASH_TYPE_KECCAK
)
8180 uint
*ptr
= digest_buf
;
8182 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",
8210 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8212 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8214 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8221 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8223 digest_buf
[ 0] = digest_buf
[ 0];
8224 digest_buf
[ 1] = digest_buf
[ 1];
8225 digest_buf
[ 2] = digest_buf
[ 2];
8226 digest_buf
[ 3] = digest_buf
[ 3];
8227 digest_buf
[ 4] = digest_buf
[ 4];
8228 digest_buf
[ 5] = digest_buf
[ 5];
8229 digest_buf
[ 6] = digest_buf
[ 6];
8230 digest_buf
[ 7] = digest_buf
[ 7];
8231 digest_buf
[ 8] = digest_buf
[ 8];
8232 digest_buf
[ 9] = digest_buf
[ 9];
8233 digest_buf
[10] = digest_buf
[10];
8234 digest_buf
[11] = digest_buf
[11];
8235 digest_buf
[12] = digest_buf
[12];
8236 digest_buf
[13] = digest_buf
[13];
8237 digest_buf
[14] = digest_buf
[14];
8238 digest_buf
[15] = digest_buf
[15];
8240 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8258 else if (hash_type
== HASH_TYPE_GOST
)
8260 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8270 else if (hash_type
== HASH_TYPE_MYSQL
)
8272 snprintf (out_buf
, len
-1, "%08x%08x",
8276 else if (hash_type
== HASH_TYPE_LOTUS5
)
8278 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8284 else if (hash_type
== HASH_TYPE_LOTUS6
)
8286 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8287 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8288 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8289 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8293 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8294 memcpy (buf
+ 5, digest_buf
, 9);
8298 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8300 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8303 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8305 else if (hash_type
== HASH_TYPE_LOTUS8
)
8309 memset (buf
, 0, sizeof (buf
));
8313 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8319 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8323 buf
[26] = salt
.salt_buf_pc
[0];
8324 buf
[27] = salt
.salt_buf_pc
[1];
8328 memcpy (buf
+ 28, digest_buf
, 8);
8330 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8334 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8336 else if (hash_type
== HASH_TYPE_CRC32
)
8338 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8342 if (salt_type
== SALT_TYPE_INTERN
)
8344 size_t pos
= strlen (out_buf
);
8346 out_buf
[pos
] = data
.separator
;
8348 char *ptr
= (char *) salt
.salt_buf
;
8350 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8352 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8356 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8358 memset (hccap
, 0, sizeof (hccap_t
));
8360 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8362 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8364 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8365 wpa_t
*wpa
= &wpas
[salt_pos
];
8367 hccap
->keyver
= wpa
->keyver
;
8369 hccap
->eapol_size
= wpa
->eapol_size
;
8371 if (wpa
->keyver
!= 1)
8375 for (uint i
= 0; i
< 64; i
++)
8377 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8380 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8384 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8389 for (int i
= 5; i
< 25; i
++)
8391 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8394 char *pke_ptr
= (char *) pke_tmp
;
8396 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8397 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8398 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8399 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8401 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8403 uint dgst_size
= data
.dgst_size
;
8405 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8407 if (wpa
->keyver
!= 1)
8411 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8412 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8413 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8414 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8416 memcpy (hccap
->keymic
, digest_tmp
, 16);
8420 memcpy (hccap
->keymic
, digest_ptr
, 16);
8424 void SuspendThreads ()
8426 if (data
.devices_status
== STATUS_RUNNING
)
8428 hc_timer_set (&data
.timer_paused
);
8430 data
.devices_status
= STATUS_PAUSED
;
8432 log_info ("Paused");
8436 void ResumeThreads ()
8438 if (data
.devices_status
== STATUS_PAUSED
)
8442 hc_timer_get (data
.timer_paused
, ms_paused
);
8444 data
.ms_paused
+= ms_paused
;
8446 data
.devices_status
= STATUS_RUNNING
;
8448 log_info ("Resumed");
8454 if (data
.devices_status
!= STATUS_RUNNING
) return;
8456 data
.devices_status
= STATUS_BYPASS
;
8458 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8461 void stop_at_checkpoint ()
8463 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8465 if (data
.devices_status
!= STATUS_RUNNING
) return;
8468 // this feature only makes sense if --restore-disable was not specified
8470 if (data
.restore_disable
== 1)
8472 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8477 // check if monitoring of Restore Point updates should be enabled or disabled
8479 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8481 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8483 // save the current restore point value
8485 data
.checkpoint_cur_words
= get_lowest_words_done ();
8487 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8491 data
.devices_status
= STATUS_RUNNING
;
8493 // reset the global value for checkpoint checks
8495 data
.checkpoint_cur_words
= 0;
8497 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8503 if (data
.devices_status
== STATUS_INIT
) return;
8504 if (data
.devices_status
== STATUS_STARTING
) return;
8506 data
.devices_status
= STATUS_ABORTED
;
8511 if (data
.devices_status
== STATUS_INIT
) return;
8512 if (data
.devices_status
== STATUS_STARTING
) return;
8514 data
.devices_status
= STATUS_QUIT
;
8517 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8521 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8525 memset (&st
, 0, sizeof (st
));
8527 stat (kernel_file
, &st
);
8529 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8531 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8533 if (num_read
!= (size_t) st
.st_size
)
8535 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8542 buf
[st
.st_size
] = 0;
8544 for (int i
= 0; i
< num_devices
; i
++)
8546 kernel_lengths
[i
] = (size_t) st
.st_size
;
8548 kernel_sources
[i
] = buf
;
8553 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8561 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8563 FILE *fp
= fopen (dst
, "wb");
8565 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8575 restore_data_t
*init_restore (int argc
, char **argv
)
8577 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8579 if (data
.restore_disable
== 0)
8581 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8585 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8589 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8598 char pidbin
[BUFSIZ
];
8603 memset (pidbin
, 0, sizeof (pidbin
));
8605 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8607 FILE *fd
= fopen (pidbin
, "rb");
8611 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8613 pidbin
[pidbin_len
] = 0;
8617 char *argv0_r
= strrchr (argv
[0], '/');
8619 char *pidbin_r
= strrchr (pidbin
, '/');
8621 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8623 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8625 if (strcmp (argv0_r
, pidbin_r
) == 0)
8627 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8634 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8636 char pidbin2
[BUFSIZ
];
8640 memset (pidbin2
, 0, sizeof (pidbin2
));
8642 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8643 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8645 pidbin
[pidbin_len
] = 0;
8646 pidbin2
[pidbin2_len
] = 0;
8650 if (strcmp (pidbin
, pidbin2
) == 0)
8652 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8660 if (rd
->version_bin
< RESTORE_MIN
)
8662 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8669 memset (rd
, 0, sizeof (restore_data_t
));
8671 rd
->version_bin
= VERSION_BIN
;
8674 rd
->pid
= getpid ();
8676 rd
->pid
= GetCurrentProcessId ();
8679 if (getcwd (rd
->cwd
, 255) == NULL
)
8692 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8694 FILE *fp
= fopen (eff_restore_file
, "rb");
8698 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8703 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8705 log_error ("ERROR: cannot read %s", eff_restore_file
);
8710 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8712 for (uint i
= 0; i
< rd
->argc
; i
++)
8716 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8718 log_error ("ERROR: cannot read %s", eff_restore_file
);
8723 size_t len
= strlen (buf
);
8725 if (len
) buf
[len
- 1] = 0;
8727 rd
->argv
[i
] = mystrdup (buf
);
8734 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8738 log_error ("Restore file is corrupted");
8741 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8743 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8745 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8750 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8754 if (chdir (rd
->cwd
))
8756 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8762 uint64_t get_lowest_words_done ()
8764 uint64_t words_cur
= -1;
8766 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8768 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8770 const uint64_t words_done
= device_param
->words_done
;
8772 if (words_done
< words_cur
) words_cur
= words_done
;
8775 // It's possible that a device's workload isn't finished right after a restore-case.
8776 // In that case, this function would return 0 and overwrite the real restore point
8777 // There's also data.words_cur which is set to rd->words_cur but it changes while
8778 // the attack is running therefore we should stick to rd->words_cur.
8779 // Note that -s influences rd->words_cur we should keep a close look on that.
8781 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8786 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8788 uint64_t words_cur
= get_lowest_words_done ();
8790 rd
->words_cur
= words_cur
;
8792 FILE *fp
= fopen (new_restore_file
, "wb");
8796 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8801 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8803 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8808 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8810 for (uint i
= 0; i
< rd
->argc
; i
++)
8812 fprintf (fp
, "%s", rd
->argv
[i
]);
8818 fsync (fileno (fp
));
8823 void cycle_restore ()
8825 const char *eff_restore_file
= data
.eff_restore_file
;
8826 const char *new_restore_file
= data
.new_restore_file
;
8828 restore_data_t
*rd
= data
.rd
;
8830 write_restore (new_restore_file
, rd
);
8834 memset (&st
, 0, sizeof(st
));
8836 if (stat (eff_restore_file
, &st
) == 0)
8838 if (unlink (eff_restore_file
))
8840 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8844 if (rename (new_restore_file
, eff_restore_file
))
8846 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8850 void check_checkpoint ()
8852 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8854 uint64_t words_cur
= get_lowest_words_done ();
8856 if (words_cur
!= data
.checkpoint_cur_words
)
8866 uint
set_kernel_accel (uint hash_mode
)
8870 case 0: return GET_ACCEL (0);
8871 case 10: return GET_ACCEL (10);
8872 case 11: return GET_ACCEL (11);
8873 case 12: return GET_ACCEL (12);
8874 case 20: return GET_ACCEL (20);
8875 case 21: return GET_ACCEL (21);
8876 case 22: return GET_ACCEL (22);
8877 case 23: return GET_ACCEL (23);
8878 case 30: return GET_ACCEL (30);
8879 case 40: return GET_ACCEL (40);
8880 case 50: return GET_ACCEL (50);
8881 case 60: return GET_ACCEL (60);
8882 case 100: return GET_ACCEL (100);
8883 case 101: return GET_ACCEL (101);
8884 case 110: return GET_ACCEL (110);
8885 case 111: return GET_ACCEL (111);
8886 case 112: return GET_ACCEL (112);
8887 case 120: return GET_ACCEL (120);
8888 case 121: return GET_ACCEL (121);
8889 case 122: return GET_ACCEL (122);
8890 case 124: return GET_ACCEL (124);
8891 case 130: return GET_ACCEL (130);
8892 case 131: return GET_ACCEL (131);
8893 case 132: return GET_ACCEL (132);
8894 case 133: return GET_ACCEL (133);
8895 case 140: return GET_ACCEL (140);
8896 case 141: return GET_ACCEL (141);
8897 case 150: return GET_ACCEL (150);
8898 case 160: return GET_ACCEL (160);
8899 case 190: return GET_ACCEL (190);
8900 case 200: return GET_ACCEL (200);
8901 case 300: return GET_ACCEL (300);
8902 case 400: return GET_ACCEL (400);
8903 case 500: return GET_ACCEL (500);
8904 case 501: return GET_ACCEL (501);
8905 case 900: return GET_ACCEL (900);
8906 case 910: return GET_ACCEL (910);
8907 case 1000: return GET_ACCEL (1000);
8908 case 1100: return GET_ACCEL (1100);
8909 case 1400: return GET_ACCEL (1400);
8910 case 1410: return GET_ACCEL (1410);
8911 case 1420: return GET_ACCEL (1420);
8912 case 1421: return GET_ACCEL (1421);
8913 case 1430: return GET_ACCEL (1430);
8914 case 1440: return GET_ACCEL (1440);
8915 case 1441: return GET_ACCEL (1441);
8916 case 1450: return GET_ACCEL (1450);
8917 case 1460: return GET_ACCEL (1460);
8918 case 1500: return GET_ACCEL (1500);
8919 case 1600: return GET_ACCEL (1600);
8920 case 1700: return GET_ACCEL (1700);
8921 case 1710: return GET_ACCEL (1710);
8922 case 1711: return GET_ACCEL (1711);
8923 case 1720: return GET_ACCEL (1720);
8924 case 1722: return GET_ACCEL (1722);
8925 case 1730: return GET_ACCEL (1730);
8926 case 1731: return GET_ACCEL (1731);
8927 case 1740: return GET_ACCEL (1740);
8928 case 1750: return GET_ACCEL (1750);
8929 case 1760: return GET_ACCEL (1760);
8930 case 1800: return GET_ACCEL (1800);
8931 case 2100: return GET_ACCEL (2100);
8932 case 2400: return GET_ACCEL (2400);
8933 case 2410: return GET_ACCEL (2410);
8934 case 2500: return GET_ACCEL (2500);
8935 case 2600: return GET_ACCEL (2600);
8936 case 2611: return GET_ACCEL (2611);
8937 case 2612: return GET_ACCEL (2612);
8938 case 2711: return GET_ACCEL (2711);
8939 case 2811: return GET_ACCEL (2811);
8940 case 3000: return GET_ACCEL (3000);
8941 case 3100: return GET_ACCEL (3100);
8942 case 3200: return GET_ACCEL (3200);
8943 case 3710: return GET_ACCEL (3710);
8944 case 3711: return GET_ACCEL (3711);
8945 case 3800: return GET_ACCEL (3800);
8946 case 4300: return GET_ACCEL (4300);
8947 case 4400: return GET_ACCEL (4400);
8948 case 4500: return GET_ACCEL (4500);
8949 case 4700: return GET_ACCEL (4700);
8950 case 4800: return GET_ACCEL (4800);
8951 case 4900: return GET_ACCEL (4900);
8952 case 5000: return GET_ACCEL (5000);
8953 case 5100: return GET_ACCEL (5100);
8954 case 5200: return GET_ACCEL (5200);
8955 case 5300: return GET_ACCEL (5300);
8956 case 5400: return GET_ACCEL (5400);
8957 case 5500: return GET_ACCEL (5500);
8958 case 5600: return GET_ACCEL (5600);
8959 case 5700: return GET_ACCEL (5700);
8960 case 5800: return GET_ACCEL (5800);
8961 case 6000: return GET_ACCEL (6000);
8962 case 6100: return GET_ACCEL (6100);
8963 case 6211: return GET_ACCEL (6211);
8964 case 6212: return GET_ACCEL (6212);
8965 case 6213: return GET_ACCEL (6213);
8966 case 6221: return GET_ACCEL (6221);
8967 case 6222: return GET_ACCEL (6222);
8968 case 6223: return GET_ACCEL (6223);
8969 case 6231: return GET_ACCEL (6231);
8970 case 6232: return GET_ACCEL (6232);
8971 case 6233: return GET_ACCEL (6233);
8972 case 6241: return GET_ACCEL (6241);
8973 case 6242: return GET_ACCEL (6242);
8974 case 6243: return GET_ACCEL (6243);
8975 case 6300: return GET_ACCEL (6300);
8976 case 6400: return GET_ACCEL (6400);
8977 case 6500: return GET_ACCEL (6500);
8978 case 6600: return GET_ACCEL (6600);
8979 case 6700: return GET_ACCEL (6700);
8980 case 6800: return GET_ACCEL (6800);
8981 case 6900: return GET_ACCEL (6900);
8982 case 7100: return GET_ACCEL (7100);
8983 case 7200: return GET_ACCEL (7200);
8984 case 7300: return GET_ACCEL (7300);
8985 case 7400: return GET_ACCEL (7400);
8986 case 7500: return GET_ACCEL (7500);
8987 case 7600: return GET_ACCEL (7600);
8988 case 7700: return GET_ACCEL (7700);
8989 case 7800: return GET_ACCEL (7800);
8990 case 7900: return GET_ACCEL (7900);
8991 case 8000: return GET_ACCEL (8000);
8992 case 8100: return GET_ACCEL (8100);
8993 case 8200: return GET_ACCEL (8200);
8994 case 8300: return GET_ACCEL (8300);
8995 case 8400: return GET_ACCEL (8400);
8996 case 8500: return GET_ACCEL (8500);
8997 case 8600: return GET_ACCEL (8600);
8998 case 8700: return GET_ACCEL (8700);
8999 case 8800: return GET_ACCEL (8800);
9000 case 8900: return GET_ACCEL (8900);
9001 case 9000: return GET_ACCEL (9000);
9002 case 9100: return GET_ACCEL (9100);
9003 case 9200: return GET_ACCEL (9200);
9004 case 9300: return GET_ACCEL (9300);
9005 case 9400: return GET_ACCEL (9400);
9006 case 9500: return GET_ACCEL (9500);
9007 case 9600: return GET_ACCEL (9600);
9008 case 9700: return GET_ACCEL (9700);
9009 case 9710: return GET_ACCEL (9710);
9010 case 9720: return GET_ACCEL (9720);
9011 case 9800: return GET_ACCEL (9800);
9012 case 9810: return GET_ACCEL (9810);
9013 case 9820: return GET_ACCEL (9820);
9014 case 9900: return GET_ACCEL (9900);
9015 case 10000: return GET_ACCEL (10000);
9016 case 10100: return GET_ACCEL (10100);
9017 case 10200: return GET_ACCEL (10200);
9018 case 10300: return GET_ACCEL (10300);
9019 case 10400: return GET_ACCEL (10400);
9020 case 10410: return GET_ACCEL (10410);
9021 case 10420: return GET_ACCEL (10420);
9022 case 10500: return GET_ACCEL (10500);
9023 case 10600: return GET_ACCEL (10600);
9024 case 10700: return GET_ACCEL (10700);
9025 case 10800: return GET_ACCEL (10800);
9026 case 10900: return GET_ACCEL (10900);
9027 case 11000: return GET_ACCEL (11000);
9028 case 11100: return GET_ACCEL (11100);
9029 case 11200: return GET_ACCEL (11200);
9030 case 11300: return GET_ACCEL (11300);
9031 case 11400: return GET_ACCEL (11400);
9032 case 11500: return GET_ACCEL (11500);
9033 case 11600: return GET_ACCEL (11600);
9034 case 11700: return GET_ACCEL (11700);
9035 case 11800: return GET_ACCEL (11800);
9036 case 11900: return GET_ACCEL (11900);
9037 case 12000: return GET_ACCEL (12000);
9038 case 12100: return GET_ACCEL (12100);
9039 case 12200: return GET_ACCEL (12200);
9040 case 12300: return GET_ACCEL (12300);
9041 case 12400: return GET_ACCEL (12400);
9042 case 12500: return GET_ACCEL (12500);
9043 case 12600: return GET_ACCEL (12600);
9044 case 12700: return GET_ACCEL (12700);
9045 case 12800: return GET_ACCEL (12800);
9046 case 12900: return GET_ACCEL (12900);
9047 case 13000: return GET_ACCEL (13000);
9053 uint
set_kernel_loops (uint hash_mode
)
9057 case 0: return GET_LOOPS (0);
9058 case 10: return GET_LOOPS (10);
9059 case 11: return GET_LOOPS (11);
9060 case 12: return GET_LOOPS (12);
9061 case 20: return GET_LOOPS (20);
9062 case 21: return GET_LOOPS (21);
9063 case 22: return GET_LOOPS (22);
9064 case 23: return GET_LOOPS (23);
9065 case 30: return GET_LOOPS (30);
9066 case 40: return GET_LOOPS (40);
9067 case 50: return GET_LOOPS (50);
9068 case 60: return GET_LOOPS (60);
9069 case 100: return GET_LOOPS (100);
9070 case 101: return GET_LOOPS (101);
9071 case 110: return GET_LOOPS (110);
9072 case 111: return GET_LOOPS (111);
9073 case 112: return GET_LOOPS (112);
9074 case 120: return GET_LOOPS (120);
9075 case 121: return GET_LOOPS (121);
9076 case 122: return GET_LOOPS (122);
9077 case 124: return GET_LOOPS (124);
9078 case 130: return GET_LOOPS (130);
9079 case 131: return GET_LOOPS (131);
9080 case 132: return GET_LOOPS (132);
9081 case 133: return GET_LOOPS (133);
9082 case 140: return GET_LOOPS (140);
9083 case 141: return GET_LOOPS (141);
9084 case 150: return GET_LOOPS (150);
9085 case 160: return GET_LOOPS (160);
9086 case 190: return GET_LOOPS (190);
9087 case 200: return GET_LOOPS (200);
9088 case 300: return GET_LOOPS (300);
9089 case 400: return GET_LOOPS (400);
9090 case 500: return GET_LOOPS (500);
9091 case 501: return GET_LOOPS (501);
9092 case 900: return GET_LOOPS (900);
9093 case 910: return GET_LOOPS (910);
9094 case 1000: return GET_LOOPS (1000);
9095 case 1100: return GET_LOOPS (1100);
9096 case 1400: return GET_LOOPS (1400);
9097 case 1410: return GET_LOOPS (1410);
9098 case 1420: return GET_LOOPS (1420);
9099 case 1421: return GET_LOOPS (1421);
9100 case 1430: return GET_LOOPS (1430);
9101 case 1440: return GET_LOOPS (1440);
9102 case 1441: return GET_LOOPS (1441);
9103 case 1450: return GET_LOOPS (1450);
9104 case 1460: return GET_LOOPS (1460);
9105 case 1500: return GET_LOOPS (1500);
9106 case 1600: return GET_LOOPS (1600);
9107 case 1700: return GET_LOOPS (1700);
9108 case 1710: return GET_LOOPS (1710);
9109 case 1711: return GET_LOOPS (1711);
9110 case 1720: return GET_LOOPS (1720);
9111 case 1722: return GET_LOOPS (1722);
9112 case 1730: return GET_LOOPS (1730);
9113 case 1731: return GET_LOOPS (1731);
9114 case 1740: return GET_LOOPS (1740);
9115 case 1750: return GET_LOOPS (1750);
9116 case 1760: return GET_LOOPS (1760);
9117 case 1800: return GET_LOOPS (1800);
9118 case 2100: return GET_LOOPS (2100);
9119 case 2400: return GET_LOOPS (2400);
9120 case 2410: return GET_LOOPS (2410);
9121 case 2500: return GET_LOOPS (2500);
9122 case 2600: return GET_LOOPS (2600);
9123 case 2611: return GET_LOOPS (2611);
9124 case 2612: return GET_LOOPS (2612);
9125 case 2711: return GET_LOOPS (2711);
9126 case 2811: return GET_LOOPS (2811);
9127 case 3000: return GET_LOOPS (3000);
9128 case 3100: return GET_LOOPS (3100);
9129 case 3200: return GET_LOOPS (3200);
9130 case 3710: return GET_LOOPS (3710);
9131 case 3711: return GET_LOOPS (3711);
9132 case 3800: return GET_LOOPS (3800);
9133 case 4300: return GET_LOOPS (4300);
9134 case 4400: return GET_LOOPS (4400);
9135 case 4500: return GET_LOOPS (4500);
9136 case 4700: return GET_LOOPS (4700);
9137 case 4800: return GET_LOOPS (4800);
9138 case 4900: return GET_LOOPS (4900);
9139 case 5000: return GET_LOOPS (5000);
9140 case 5100: return GET_LOOPS (5100);
9141 case 5200: return GET_LOOPS (5200);
9142 case 5300: return GET_LOOPS (5300);
9143 case 5400: return GET_LOOPS (5400);
9144 case 5500: return GET_LOOPS (5500);
9145 case 5600: return GET_LOOPS (5600);
9146 case 5700: return GET_LOOPS (5700);
9147 case 5800: return GET_LOOPS (5800);
9148 case 6000: return GET_LOOPS (6000);
9149 case 6100: return GET_LOOPS (6100);
9150 case 6211: return GET_LOOPS (6211);
9151 case 6212: return GET_LOOPS (6212);
9152 case 6213: return GET_LOOPS (6213);
9153 case 6221: return GET_LOOPS (6221);
9154 case 6222: return GET_LOOPS (6222);
9155 case 6223: return GET_LOOPS (6223);
9156 case 6231: return GET_LOOPS (6231);
9157 case 6232: return GET_LOOPS (6232);
9158 case 6233: return GET_LOOPS (6233);
9159 case 6241: return GET_LOOPS (6241);
9160 case 6242: return GET_LOOPS (6242);
9161 case 6243: return GET_LOOPS (6243);
9162 case 6300: return GET_LOOPS (6300);
9163 case 6400: return GET_LOOPS (6400);
9164 case 6500: return GET_LOOPS (6500);
9165 case 6600: return GET_LOOPS (6600);
9166 case 6700: return GET_LOOPS (6700);
9167 case 6800: return GET_LOOPS (6800);
9168 case 6900: return GET_LOOPS (6900);
9169 case 7100: return GET_LOOPS (7100);
9170 case 7200: return GET_LOOPS (7200);
9171 case 7300: return GET_LOOPS (7300);
9172 case 7400: return GET_LOOPS (7400);
9173 case 7500: return GET_LOOPS (7500);
9174 case 7600: return GET_LOOPS (7600);
9175 case 7700: return GET_LOOPS (7700);
9176 case 7800: return GET_LOOPS (7800);
9177 case 7900: return GET_LOOPS (7900);
9178 case 8000: return GET_LOOPS (8000);
9179 case 8100: return GET_LOOPS (8100);
9180 case 8200: return GET_LOOPS (8200);
9181 case 8300: return GET_LOOPS (8300);
9182 case 8400: return GET_LOOPS (8400);
9183 case 8500: return GET_LOOPS (8500);
9184 case 8600: return GET_LOOPS (8600);
9185 case 8700: return GET_LOOPS (8700);
9186 case 8800: return GET_LOOPS (8800);
9187 case 8900: return GET_LOOPS (8900);
9188 case 9000: return GET_LOOPS (9000);
9189 case 9100: return GET_LOOPS (9100);
9190 case 9200: return GET_LOOPS (9200);
9191 case 9300: return GET_LOOPS (9300);
9192 case 9400: return GET_LOOPS (9400);
9193 case 9500: return GET_LOOPS (9500);
9194 case 9600: return GET_LOOPS (9600);
9195 case 9700: return GET_LOOPS (9700);
9196 case 9710: return GET_LOOPS (9710);
9197 case 9720: return GET_LOOPS (9720);
9198 case 9800: return GET_LOOPS (9800);
9199 case 9810: return GET_LOOPS (9810);
9200 case 9820: return GET_LOOPS (9820);
9201 case 9900: return GET_LOOPS (9900);
9202 case 10000: return GET_LOOPS (10000);
9203 case 10100: return GET_LOOPS (10100);
9204 case 10200: return GET_LOOPS (10200);
9205 case 10300: return GET_LOOPS (10300);
9206 case 10400: return GET_LOOPS (10400);
9207 case 10410: return GET_LOOPS (10410);
9208 case 10420: return GET_LOOPS (10420);
9209 case 10500: return GET_LOOPS (10500);
9210 case 10600: return GET_LOOPS (10600);
9211 case 10700: return GET_LOOPS (10700);
9212 case 10800: return GET_LOOPS (10800);
9213 case 10900: return GET_LOOPS (10900);
9214 case 11000: return GET_LOOPS (11000);
9215 case 11100: return GET_LOOPS (11100);
9216 case 11200: return GET_LOOPS (11200);
9217 case 11300: return GET_LOOPS (11300);
9218 case 11400: return GET_LOOPS (11400);
9219 case 11500: return GET_LOOPS (11500);
9220 case 11600: return GET_LOOPS (11600);
9221 case 11700: return GET_LOOPS (11700);
9222 case 11800: return GET_LOOPS (11800);
9223 case 11900: return GET_LOOPS (11900);
9224 case 12000: return GET_LOOPS (12000);
9225 case 12100: return GET_LOOPS (12100);
9226 case 12200: return GET_LOOPS (12200);
9227 case 12300: return GET_LOOPS (12300);
9228 case 12400: return GET_LOOPS (12400);
9229 case 12500: return GET_LOOPS (12500);
9230 case 12600: return GET_LOOPS (12600);
9231 case 12700: return GET_LOOPS (12700);
9232 case 12800: return GET_LOOPS (12800);
9233 case 12900: return GET_LOOPS (12900);
9234 case 13000: return GET_LOOPS (13000);
9244 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9248 if (salt_len
> sizeof(tmp
))
9253 memset (tmp
, 0, sizeof (tmp
));
9254 memcpy (tmp
, in
, salt_len
);
9256 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9258 if ((salt_len
% 2) == 0)
9260 uint new_salt_len
= salt_len
/ 2;
9262 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9264 char p0
= tmp
[j
+ 0];
9265 char p1
= tmp
[j
+ 1];
9267 tmp
[i
] = hex_convert (p1
) << 0;
9268 tmp
[i
] |= hex_convert (p0
) << 4;
9271 salt_len
= new_salt_len
;
9278 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9280 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9283 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9285 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9289 uint
*tmp_uint
= (uint
*) tmp
;
9291 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9292 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9293 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9294 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9295 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9296 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9297 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9298 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9299 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9300 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9302 salt_len
= salt_len
* 2;
9310 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9312 lowercase (tmp
, salt_len
);
9315 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9317 uppercase (tmp
, salt_len
);
9320 uint len
= salt_len
;
9322 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9327 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9332 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9334 uint
*tmp_uint
= (uint
*) tmp
;
9340 for (uint i
= 0; i
< max
; i
++)
9342 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9345 // Important: we may need to increase the length of memcpy since
9346 // we don't want to "loose" some swapped bytes (could happen if
9347 // they do not perfectly fit in the 4-byte blocks)
9348 // Memcpy does always copy the bytes in the BE order, but since
9349 // we swapped them, some important bytes could be in positions
9350 // we normally skip with the original len
9352 if (len
% 4) len
+= 4 - (len
% 4);
9355 memcpy (out
, tmp
, len
);
9360 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9362 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9364 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9366 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9368 salt_t
*salt
= hash_buf
->salt
;
9370 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9372 char *iter_pos
= input_buf
+ 4;
9374 salt
->salt_iter
= 1 << atoi (iter_pos
);
9376 char *salt_pos
= strchr (iter_pos
, '$');
9378 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9384 salt
->salt_len
= salt_len
;
9388 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9390 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9392 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9394 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9396 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9397 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9398 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9399 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9401 char *hash_pos
= salt_pos
+ 22;
9403 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9405 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9407 memcpy (digest
, tmp_buf
, 24);
9409 digest
[0] = byte_swap_32 (digest
[0]);
9410 digest
[1] = byte_swap_32 (digest
[1]);
9411 digest
[2] = byte_swap_32 (digest
[2]);
9412 digest
[3] = byte_swap_32 (digest
[3]);
9413 digest
[4] = byte_swap_32 (digest
[4]);
9414 digest
[5] = byte_swap_32 (digest
[5]);
9416 digest
[5] &= ~0xff; // its just 23 not 24 !
9421 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9423 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9425 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9429 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9431 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9433 memcpy (digest
, tmp_buf
, 32);
9435 digest
[0] = byte_swap_32 (digest
[0]);
9436 digest
[1] = byte_swap_32 (digest
[1]);
9437 digest
[2] = byte_swap_32 (digest
[2]);
9438 digest
[3] = byte_swap_32 (digest
[3]);
9439 digest
[4] = byte_swap_32 (digest
[4]);
9440 digest
[5] = byte_swap_32 (digest
[5]);
9441 digest
[6] = byte_swap_32 (digest
[6]);
9442 digest
[7] = byte_swap_32 (digest
[7]);
9444 digest
[0] -= SHA256M_A
;
9445 digest
[1] -= SHA256M_B
;
9446 digest
[2] -= SHA256M_C
;
9447 digest
[3] -= SHA256M_D
;
9448 digest
[4] -= SHA256M_E
;
9449 digest
[5] -= SHA256M_F
;
9450 digest
[6] -= SHA256M_G
;
9451 digest
[7] -= SHA256M_H
;
9456 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9458 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9460 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9462 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9463 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9465 digest
[0] = byte_swap_32 (digest
[0]);
9466 digest
[1] = byte_swap_32 (digest
[1]);
9470 IP (digest
[0], digest
[1], tt
);
9472 digest
[0] = digest
[0];
9473 digest
[1] = digest
[1];
9480 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9482 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9484 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9486 salt_t
*salt
= hash_buf
->salt
;
9488 char *hash_pos
= input_buf
+ 8;
9490 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9491 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9492 digest
[2] = hex_to_uint (&hash_pos
[16]);
9493 digest
[3] = hex_to_uint (&hash_pos
[24]);
9494 digest
[4] = hex_to_uint (&hash_pos
[32]);
9496 digest
[0] -= SHA1M_A
;
9497 digest
[1] -= SHA1M_B
;
9498 digest
[2] -= SHA1M_C
;
9499 digest
[3] -= SHA1M_D
;
9500 digest
[4] -= SHA1M_E
;
9504 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9506 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9508 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9510 salt
->salt_len
= salt_len
;
9515 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9517 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9519 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9521 salt_t
*salt
= hash_buf
->salt
;
9523 char *hash_pos
= input_buf
+ 8;
9525 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9526 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9527 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9528 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9529 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9530 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9531 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9532 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9534 digest
[0] -= SHA512M_A
;
9535 digest
[1] -= SHA512M_B
;
9536 digest
[2] -= SHA512M_C
;
9537 digest
[3] -= SHA512M_D
;
9538 digest
[4] -= SHA512M_E
;
9539 digest
[5] -= SHA512M_F
;
9540 digest
[6] -= SHA512M_G
;
9541 digest
[7] -= SHA512M_H
;
9545 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9547 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9549 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9551 salt
->salt_len
= salt_len
;
9556 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9558 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9560 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9564 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9567 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9569 salt_t
*salt
= hash_buf
->salt
;
9571 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9572 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9573 digest
[2] = hex_to_uint (&input_buf
[16]);
9574 digest
[3] = hex_to_uint (&input_buf
[24]);
9576 digest
[0] = byte_swap_32 (digest
[0]);
9577 digest
[1] = byte_swap_32 (digest
[1]);
9578 digest
[2] = byte_swap_32 (digest
[2]);
9579 digest
[3] = byte_swap_32 (digest
[3]);
9581 digest
[0] -= MD5M_A
;
9582 digest
[1] -= MD5M_B
;
9583 digest
[2] -= MD5M_C
;
9584 digest
[3] -= MD5M_D
;
9586 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9588 uint salt_len
= input_len
- 32 - 1;
9590 char *salt_buf
= input_buf
+ 32 + 1;
9592 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9594 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9596 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9598 salt
->salt_len
= salt_len
;
9603 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9605 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9607 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9611 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9616 char clean_input_buf
[32];
9618 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9619 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9621 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9625 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9631 clean_input_buf
[k
] = input_buf
[i
];
9639 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9641 salt_t
*salt
= hash_buf
->salt
;
9643 char a
, b
, c
, d
, e
, f
;
9645 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9646 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9647 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9648 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9649 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9650 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9652 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9653 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9655 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9656 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9657 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9658 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9659 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9660 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9662 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9663 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9665 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9666 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9667 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9668 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9669 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9670 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9672 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9673 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9675 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9676 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9677 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9678 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9679 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9680 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9682 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9683 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9685 digest
[0] = byte_swap_32 (digest
[0]);
9686 digest
[1] = byte_swap_32 (digest
[1]);
9687 digest
[2] = byte_swap_32 (digest
[2]);
9688 digest
[3] = byte_swap_32 (digest
[3]);
9690 digest
[0] -= MD5M_A
;
9691 digest
[1] -= MD5M_B
;
9692 digest
[2] -= MD5M_C
;
9693 digest
[3] -= MD5M_D
;
9695 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9697 uint salt_len
= input_len
- 30 - 1;
9699 char *salt_buf
= input_buf
+ 30 + 1;
9701 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9703 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9705 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9706 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9708 salt
->salt_len
= salt_len
;
9710 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9712 salt
->salt_len
+= 22;
9717 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9719 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9721 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9725 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9728 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9730 salt_t
*salt
= hash_buf
->salt
;
9732 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9733 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9734 digest
[2] = hex_to_uint (&input_buf
[16]);
9735 digest
[3] = hex_to_uint (&input_buf
[24]);
9736 digest
[4] = hex_to_uint (&input_buf
[32]);
9738 digest
[0] -= SHA1M_A
;
9739 digest
[1] -= SHA1M_B
;
9740 digest
[2] -= SHA1M_C
;
9741 digest
[3] -= SHA1M_D
;
9742 digest
[4] -= SHA1M_E
;
9744 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9746 uint salt_len
= input_len
- 40 - 1;
9748 char *salt_buf
= input_buf
+ 40 + 1;
9750 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9752 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9754 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9756 salt
->salt_len
= salt_len
;
9761 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9763 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9765 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9769 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9772 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9774 char *iter_pos
= input_buf
+ 6;
9776 salt_t
*salt
= hash_buf
->salt
;
9778 salt
->salt_iter
= atoi (iter_pos
) - 1;
9780 char *salt_pos
= strchr (iter_pos
, '#');
9782 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9786 char *digest_pos
= strchr (salt_pos
, '#');
9788 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9792 uint salt_len
= digest_pos
- salt_pos
- 1;
9794 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9796 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9797 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9798 digest
[2] = hex_to_uint (&digest_pos
[16]);
9799 digest
[3] = hex_to_uint (&digest_pos
[24]);
9801 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9803 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9805 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9807 salt
->salt_len
= salt_len
;
9812 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9814 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9816 salt_t
*salt
= hash_buf
->salt
;
9818 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9822 memcpy (&in
, input_buf
, input_len
);
9824 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9826 memcpy (digest
, in
.keymic
, 16);
9829 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9830 The phrase "Pairwise key expansion"
9831 Access Point Address (Referred to as Authenticator Address AA)
9832 Supplicant Address (referred to as Supplicant Address SA)
9833 Access Point Nonce (referred to as Authenticator Anonce)
9834 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9837 uint salt_len
= strlen (in
.essid
);
9839 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9841 salt
->salt_len
= salt_len
;
9843 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9845 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9847 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9849 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9851 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9852 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9856 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9857 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9860 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9862 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9863 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9867 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9868 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9871 for (int i
= 0; i
< 25; i
++)
9873 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9876 wpa
->keyver
= in
.keyver
;
9878 if (wpa
->keyver
> 255)
9880 log_info ("ATTENTION!");
9881 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9882 log_info (" This could be due to a recent aircrack-ng bug.");
9883 log_info (" The key version was automatically reset to a reasonable value.");
9886 wpa
->keyver
&= 0xff;
9889 wpa
->eapol_size
= in
.eapol_size
;
9891 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9893 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9895 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9897 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9899 if (wpa
->keyver
== 1)
9905 digest
[0] = byte_swap_32 (digest
[0]);
9906 digest
[1] = byte_swap_32 (digest
[1]);
9907 digest
[2] = byte_swap_32 (digest
[2]);
9908 digest
[3] = byte_swap_32 (digest
[3]);
9910 for (int i
= 0; i
< 64; i
++)
9912 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9916 salt
->salt_buf
[10] = digest
[1];
9917 salt
->salt_buf
[11] = digest
[2];
9922 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9924 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9926 salt_t
*salt
= hash_buf
->salt
;
9930 log_error ("Password Safe v2 container not specified");
9935 FILE *fp
= fopen (input_buf
, "rb");
9939 log_error ("%s: %s", input_buf
, strerror (errno
));
9948 uint32_t salt
[5]; // unused, but makes better valid check
9949 uint32_t iv
[2]; // unused, but makes better valid check
9955 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9959 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9961 salt
->salt_buf
[0] = buf
.random
[0];
9962 salt
->salt_buf
[1] = buf
.random
[1];
9965 salt
->salt_iter
= 1000;
9967 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9968 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9969 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9970 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9971 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9976 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9978 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9980 salt_t
*salt
= hash_buf
->salt
;
9984 log_error (".psafe3 not specified");
9989 FILE *fp
= fopen (input_buf
, "rb");
9993 log_error ("%s: %s", input_buf
, strerror (errno
));
10000 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10004 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10006 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10008 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10010 salt
->salt_iter
= in
.iterations
+ 1;
10012 salt
->salt_buf
[0] = in
.salt_buf
[0];
10013 salt
->salt_buf
[1] = in
.salt_buf
[1];
10014 salt
->salt_buf
[2] = in
.salt_buf
[2];
10015 salt
->salt_buf
[3] = in
.salt_buf
[3];
10016 salt
->salt_buf
[4] = in
.salt_buf
[4];
10017 salt
->salt_buf
[5] = in
.salt_buf
[5];
10018 salt
->salt_buf
[6] = in
.salt_buf
[6];
10019 salt
->salt_buf
[7] = in
.salt_buf
[7];
10021 salt
->salt_len
= 32;
10023 digest
[0] = in
.hash_buf
[0];
10024 digest
[1] = in
.hash_buf
[1];
10025 digest
[2] = in
.hash_buf
[2];
10026 digest
[3] = in
.hash_buf
[3];
10027 digest
[4] = in
.hash_buf
[4];
10028 digest
[5] = in
.hash_buf
[5];
10029 digest
[6] = in
.hash_buf
[6];
10030 digest
[7] = in
.hash_buf
[7];
10032 digest
[0] = byte_swap_32 (digest
[0]);
10033 digest
[1] = byte_swap_32 (digest
[1]);
10034 digest
[2] = byte_swap_32 (digest
[2]);
10035 digest
[3] = byte_swap_32 (digest
[3]);
10036 digest
[4] = byte_swap_32 (digest
[4]);
10037 digest
[5] = byte_swap_32 (digest
[5]);
10038 digest
[6] = byte_swap_32 (digest
[6]);
10039 digest
[7] = byte_swap_32 (digest
[7]);
10041 return (PARSER_OK
);
10044 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10046 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10048 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10050 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10052 salt_t
*salt
= hash_buf
->salt
;
10054 char *iter_pos
= input_buf
+ 3;
10056 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10058 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10060 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10062 salt
->salt_iter
= salt_iter
;
10064 char *salt_pos
= iter_pos
+ 1;
10068 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10070 salt
->salt_len
= salt_len
;
10072 char *hash_pos
= salt_pos
+ salt_len
;
10074 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10076 return (PARSER_OK
);
10079 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10081 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10083 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10085 salt_t
*salt
= hash_buf
->salt
;
10087 char *salt_pos
= input_buf
+ 3;
10089 uint iterations_len
= 0;
10091 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10095 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10097 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10098 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10102 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10106 iterations_len
+= 8;
10110 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10113 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10115 char *hash_pos
= strchr (salt_pos
, '$');
10117 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10119 uint salt_len
= hash_pos
- salt_pos
;
10121 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10123 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10125 salt
->salt_len
= salt_len
;
10129 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10131 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10133 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10135 return (PARSER_OK
);
10138 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10140 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10142 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10144 salt_t
*salt
= hash_buf
->salt
;
10146 char *salt_pos
= input_buf
+ 6;
10148 uint iterations_len
= 0;
10150 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10154 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10156 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10157 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10161 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10165 iterations_len
+= 8;
10169 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10172 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10174 char *hash_pos
= strchr (salt_pos
, '$');
10176 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10178 uint salt_len
= hash_pos
- salt_pos
;
10180 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10182 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10184 salt
->salt_len
= salt_len
;
10188 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10190 return (PARSER_OK
);
10193 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10195 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10197 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10199 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10201 salt_t
*salt
= hash_buf
->salt
;
10203 char *salt_pos
= input_buf
+ 14;
10205 char *hash_pos
= strchr (salt_pos
, '*');
10207 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10211 uint salt_len
= hash_pos
- salt_pos
- 1;
10213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10215 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10217 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10219 salt
->salt_len
= salt_len
;
10221 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10223 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10225 memcpy (digest
, tmp_buf
, 20);
10227 digest
[0] = byte_swap_32 (digest
[0]);
10228 digest
[1] = byte_swap_32 (digest
[1]);
10229 digest
[2] = byte_swap_32 (digest
[2]);
10230 digest
[3] = byte_swap_32 (digest
[3]);
10231 digest
[4] = byte_swap_32 (digest
[4]);
10233 digest
[0] -= SHA1M_A
;
10234 digest
[1] -= SHA1M_B
;
10235 digest
[2] -= SHA1M_C
;
10236 digest
[3] -= SHA1M_D
;
10237 digest
[4] -= SHA1M_E
;
10239 return (PARSER_OK
);
10242 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10244 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10246 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10248 if (c12
& 3) return (PARSER_HASH_VALUE
);
10250 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10252 salt_t
*salt
= hash_buf
->salt
;
10254 // for ascii_digest
10255 salt
->salt_sign
[0] = input_buf
[0];
10256 salt
->salt_sign
[1] = input_buf
[1];
10258 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10259 | itoa64_to_int (input_buf
[1]) << 6;
10261 salt
->salt_len
= 2;
10265 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10267 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10269 memcpy (digest
, tmp_buf
, 8);
10273 IP (digest
[0], digest
[1], tt
);
10278 return (PARSER_OK
);
10281 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10283 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10285 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10287 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10288 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10289 digest
[2] = hex_to_uint (&input_buf
[16]);
10290 digest
[3] = hex_to_uint (&input_buf
[24]);
10292 digest
[0] = byte_swap_32 (digest
[0]);
10293 digest
[1] = byte_swap_32 (digest
[1]);
10294 digest
[2] = byte_swap_32 (digest
[2]);
10295 digest
[3] = byte_swap_32 (digest
[3]);
10297 digest
[0] -= MD4M_A
;
10298 digest
[1] -= MD4M_B
;
10299 digest
[2] -= MD4M_C
;
10300 digest
[3] -= MD4M_D
;
10302 return (PARSER_OK
);
10305 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10307 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10309 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10313 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10316 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10318 salt_t
*salt
= hash_buf
->salt
;
10320 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10321 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10322 digest
[2] = hex_to_uint (&input_buf
[16]);
10323 digest
[3] = hex_to_uint (&input_buf
[24]);
10325 digest
[0] = byte_swap_32 (digest
[0]);
10326 digest
[1] = byte_swap_32 (digest
[1]);
10327 digest
[2] = byte_swap_32 (digest
[2]);
10328 digest
[3] = byte_swap_32 (digest
[3]);
10330 digest
[0] -= MD4M_A
;
10331 digest
[1] -= MD4M_B
;
10332 digest
[2] -= MD4M_C
;
10333 digest
[3] -= MD4M_D
;
10335 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10337 uint salt_len
= input_len
- 32 - 1;
10339 char *salt_buf
= input_buf
+ 32 + 1;
10341 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10343 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10345 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10347 salt
->salt_len
= salt_len
;
10349 return (PARSER_OK
);
10352 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10354 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10356 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10358 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10359 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10360 digest
[2] = hex_to_uint (&input_buf
[16]);
10361 digest
[3] = hex_to_uint (&input_buf
[24]);
10363 digest
[0] = byte_swap_32 (digest
[0]);
10364 digest
[1] = byte_swap_32 (digest
[1]);
10365 digest
[2] = byte_swap_32 (digest
[2]);
10366 digest
[3] = byte_swap_32 (digest
[3]);
10368 digest
[0] -= MD5M_A
;
10369 digest
[1] -= MD5M_B
;
10370 digest
[2] -= MD5M_C
;
10371 digest
[3] -= MD5M_D
;
10373 return (PARSER_OK
);
10376 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10378 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10380 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10382 digest
[0] = hex_to_uint (&input_buf
[0]);
10383 digest
[1] = hex_to_uint (&input_buf
[8]);
10387 digest
[0] = byte_swap_32 (digest
[0]);
10388 digest
[1] = byte_swap_32 (digest
[1]);
10390 return (PARSER_OK
);
10393 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10395 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10397 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10401 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10404 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10406 salt_t
*salt
= hash_buf
->salt
;
10408 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10409 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10410 digest
[2] = hex_to_uint (&input_buf
[16]);
10411 digest
[3] = hex_to_uint (&input_buf
[24]);
10413 digest
[0] = byte_swap_32 (digest
[0]);
10414 digest
[1] = byte_swap_32 (digest
[1]);
10415 digest
[2] = byte_swap_32 (digest
[2]);
10416 digest
[3] = byte_swap_32 (digest
[3]);
10418 digest
[0] -= MD5M_A
;
10419 digest
[1] -= MD5M_B
;
10420 digest
[2] -= MD5M_C
;
10421 digest
[3] -= MD5M_D
;
10423 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10425 uint salt_len
= input_len
- 32 - 1;
10427 char *salt_buf
= input_buf
+ 32 + 1;
10429 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10431 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10433 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10435 salt
->salt_len
= salt_len
;
10437 return (PARSER_OK
);
10440 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10442 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10444 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10446 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10447 | itoa64_to_int (input_buf
[ 1]) << 6
10448 | itoa64_to_int (input_buf
[ 2]) << 12
10449 | itoa64_to_int (input_buf
[ 3]) << 18;
10450 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10451 | itoa64_to_int (input_buf
[ 5]) << 6
10452 | itoa64_to_int (input_buf
[ 6]) << 12
10453 | itoa64_to_int (input_buf
[ 7]) << 18;
10454 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10455 | itoa64_to_int (input_buf
[ 9]) << 6
10456 | itoa64_to_int (input_buf
[10]) << 12
10457 | itoa64_to_int (input_buf
[11]) << 18;
10458 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10459 | itoa64_to_int (input_buf
[13]) << 6
10460 | itoa64_to_int (input_buf
[14]) << 12
10461 | itoa64_to_int (input_buf
[15]) << 18;
10463 digest
[0] -= MD5M_A
;
10464 digest
[1] -= MD5M_B
;
10465 digest
[2] -= MD5M_C
;
10466 digest
[3] -= MD5M_D
;
10468 digest
[0] &= 0x00ffffff;
10469 digest
[1] &= 0x00ffffff;
10470 digest
[2] &= 0x00ffffff;
10471 digest
[3] &= 0x00ffffff;
10473 return (PARSER_OK
);
10476 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10478 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10480 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10484 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10487 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10489 salt_t
*salt
= hash_buf
->salt
;
10491 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10492 | itoa64_to_int (input_buf
[ 1]) << 6
10493 | itoa64_to_int (input_buf
[ 2]) << 12
10494 | itoa64_to_int (input_buf
[ 3]) << 18;
10495 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10496 | itoa64_to_int (input_buf
[ 5]) << 6
10497 | itoa64_to_int (input_buf
[ 6]) << 12
10498 | itoa64_to_int (input_buf
[ 7]) << 18;
10499 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10500 | itoa64_to_int (input_buf
[ 9]) << 6
10501 | itoa64_to_int (input_buf
[10]) << 12
10502 | itoa64_to_int (input_buf
[11]) << 18;
10503 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10504 | itoa64_to_int (input_buf
[13]) << 6
10505 | itoa64_to_int (input_buf
[14]) << 12
10506 | itoa64_to_int (input_buf
[15]) << 18;
10508 digest
[0] -= MD5M_A
;
10509 digest
[1] -= MD5M_B
;
10510 digest
[2] -= MD5M_C
;
10511 digest
[3] -= MD5M_D
;
10513 digest
[0] &= 0x00ffffff;
10514 digest
[1] &= 0x00ffffff;
10515 digest
[2] &= 0x00ffffff;
10516 digest
[3] &= 0x00ffffff;
10518 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10520 uint salt_len
= input_len
- 16 - 1;
10522 char *salt_buf
= input_buf
+ 16 + 1;
10524 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10526 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10528 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10530 salt
->salt_len
= salt_len
;
10532 return (PARSER_OK
);
10535 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10537 key
[0] = (nthash
[0] >> 0);
10538 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10539 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10540 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10541 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10542 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10543 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10544 key
[7] = (nthash
[6] << 1);
10556 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10558 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10560 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10562 salt_t
*salt
= hash_buf
->salt
;
10564 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10570 char *user_pos
= input_buf
;
10572 char *unused_pos
= strchr (user_pos
, ':');
10574 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10576 uint user_len
= unused_pos
- user_pos
;
10578 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10582 char *domain_pos
= strchr (unused_pos
, ':');
10584 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10586 uint unused_len
= domain_pos
- unused_pos
;
10588 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10592 char *srvchall_pos
= strchr (domain_pos
, ':');
10594 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10596 uint domain_len
= srvchall_pos
- domain_pos
;
10598 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10602 char *hash_pos
= strchr (srvchall_pos
, ':');
10604 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10606 uint srvchall_len
= hash_pos
- srvchall_pos
;
10608 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10612 char *clichall_pos
= strchr (hash_pos
, ':');
10614 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10616 uint hash_len
= clichall_pos
- hash_pos
;
10618 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10622 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10624 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10627 * store some data for later use
10630 netntlm
->user_len
= user_len
* 2;
10631 netntlm
->domain_len
= domain_len
* 2;
10632 netntlm
->srvchall_len
= srvchall_len
/ 2;
10633 netntlm
->clichall_len
= clichall_len
/ 2;
10635 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10636 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10639 * handle username and domainname
10642 for (uint i
= 0; i
< user_len
; i
++)
10644 *userdomain_ptr
++ = user_pos
[i
];
10645 *userdomain_ptr
++ = 0;
10648 for (uint i
= 0; i
< domain_len
; i
++)
10650 *userdomain_ptr
++ = domain_pos
[i
];
10651 *userdomain_ptr
++ = 0;
10655 * handle server challenge encoding
10658 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10660 const char p0
= srvchall_pos
[i
+ 0];
10661 const char p1
= srvchall_pos
[i
+ 1];
10663 *chall_ptr
++ = hex_convert (p1
) << 0
10664 | hex_convert (p0
) << 4;
10668 * handle client challenge encoding
10671 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10673 const char p0
= clichall_pos
[i
+ 0];
10674 const char p1
= clichall_pos
[i
+ 1];
10676 *chall_ptr
++ = hex_convert (p1
) << 0
10677 | hex_convert (p0
) << 4;
10684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10686 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10688 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10690 salt
->salt_len
= salt_len
;
10692 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10693 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10694 digest
[2] = hex_to_uint (&hash_pos
[16]);
10695 digest
[3] = hex_to_uint (&hash_pos
[24]);
10697 digest
[0] = byte_swap_32 (digest
[0]);
10698 digest
[1] = byte_swap_32 (digest
[1]);
10699 digest
[2] = byte_swap_32 (digest
[2]);
10700 digest
[3] = byte_swap_32 (digest
[3]);
10702 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10704 uint digest_tmp
[2];
10706 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10707 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10709 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10710 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10712 /* special case 2: ESS */
10714 if (srvchall_len
== 48)
10716 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10720 w
[ 0] = netntlm
->chall_buf
[6];
10721 w
[ 1] = netntlm
->chall_buf
[7];
10722 w
[ 2] = netntlm
->chall_buf
[0];
10723 w
[ 3] = netntlm
->chall_buf
[1];
10746 salt
->salt_buf
[0] = dgst
[0];
10747 salt
->salt_buf
[1] = dgst
[1];
10751 /* precompute netntlmv1 exploit start */
10753 for (uint i
= 0; i
< 0x10000; i
++)
10755 uint key_md4
[2] = { i
, 0 };
10756 uint key_des
[2] = { 0, 0 };
10758 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10763 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10765 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10767 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10769 if (data3
[0] != digest_tmp
[0]) continue;
10770 if (data3
[1] != digest_tmp
[1]) continue;
10772 salt
->salt_buf
[2] = i
;
10774 salt
->salt_len
= 24;
10779 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10780 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10782 /* precompute netntlmv1 exploit stop */
10786 IP (digest
[0], digest
[1], tt
);
10787 IP (digest
[2], digest
[3], tt
);
10789 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10790 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10791 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10792 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10794 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10796 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10797 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10799 return (PARSER_OK
);
10802 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10804 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10806 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10808 salt_t
*salt
= hash_buf
->salt
;
10810 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10816 char *user_pos
= input_buf
;
10818 char *unused_pos
= strchr (user_pos
, ':');
10820 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10822 uint user_len
= unused_pos
- user_pos
;
10824 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10828 char *domain_pos
= strchr (unused_pos
, ':');
10830 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10832 uint unused_len
= domain_pos
- unused_pos
;
10834 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10838 char *srvchall_pos
= strchr (domain_pos
, ':');
10840 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10842 uint domain_len
= srvchall_pos
- domain_pos
;
10844 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10848 char *hash_pos
= strchr (srvchall_pos
, ':');
10850 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10852 uint srvchall_len
= hash_pos
- srvchall_pos
;
10854 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10858 char *clichall_pos
= strchr (hash_pos
, ':');
10860 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10862 uint hash_len
= clichall_pos
- hash_pos
;
10864 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10868 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10870 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10872 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10875 * store some data for later use
10878 netntlm
->user_len
= user_len
* 2;
10879 netntlm
->domain_len
= domain_len
* 2;
10880 netntlm
->srvchall_len
= srvchall_len
/ 2;
10881 netntlm
->clichall_len
= clichall_len
/ 2;
10883 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10884 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10887 * handle username and domainname
10890 for (uint i
= 0; i
< user_len
; i
++)
10892 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10893 *userdomain_ptr
++ = 0;
10896 for (uint i
= 0; i
< domain_len
; i
++)
10898 *userdomain_ptr
++ = domain_pos
[i
];
10899 *userdomain_ptr
++ = 0;
10902 *userdomain_ptr
++ = 0x80;
10905 * handle server challenge encoding
10908 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10910 const char p0
= srvchall_pos
[i
+ 0];
10911 const char p1
= srvchall_pos
[i
+ 1];
10913 *chall_ptr
++ = hex_convert (p1
) << 0
10914 | hex_convert (p0
) << 4;
10918 * handle client challenge encoding
10921 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10923 const char p0
= clichall_pos
[i
+ 0];
10924 const char p1
= clichall_pos
[i
+ 1];
10926 *chall_ptr
++ = hex_convert (p1
) << 0
10927 | hex_convert (p0
) << 4;
10930 *chall_ptr
++ = 0x80;
10933 * handle hash itself
10936 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10937 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10938 digest
[2] = hex_to_uint (&hash_pos
[16]);
10939 digest
[3] = hex_to_uint (&hash_pos
[24]);
10941 digest
[0] = byte_swap_32 (digest
[0]);
10942 digest
[1] = byte_swap_32 (digest
[1]);
10943 digest
[2] = byte_swap_32 (digest
[2]);
10944 digest
[3] = byte_swap_32 (digest
[3]);
10947 * reuse challange data as salt_buf, its the buffer that is most likely unique
10950 salt
->salt_buf
[0] = 0;
10951 salt
->salt_buf
[1] = 0;
10952 salt
->salt_buf
[2] = 0;
10953 salt
->salt_buf
[3] = 0;
10954 salt
->salt_buf
[4] = 0;
10955 salt
->salt_buf
[5] = 0;
10956 salt
->salt_buf
[6] = 0;
10957 salt
->salt_buf
[7] = 0;
10961 uptr
= (uint
*) netntlm
->userdomain_buf
;
10963 for (uint i
= 0; i
< 16; i
+= 16)
10965 md5_64 (uptr
, salt
->salt_buf
);
10968 uptr
= (uint
*) netntlm
->chall_buf
;
10970 for (uint i
= 0; i
< 256; i
+= 16)
10972 md5_64 (uptr
, salt
->salt_buf
);
10975 salt
->salt_len
= 16;
10977 return (PARSER_OK
);
10980 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10982 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10984 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10988 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10991 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10993 salt_t
*salt
= hash_buf
->salt
;
10995 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10996 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10997 digest
[2] = hex_to_uint (&input_buf
[16]);
10998 digest
[3] = hex_to_uint (&input_buf
[24]);
11000 digest
[0] = byte_swap_32 (digest
[0]);
11001 digest
[1] = byte_swap_32 (digest
[1]);
11002 digest
[2] = byte_swap_32 (digest
[2]);
11003 digest
[3] = byte_swap_32 (digest
[3]);
11005 digest
[0] -= MD5M_A
;
11006 digest
[1] -= MD5M_B
;
11007 digest
[2] -= MD5M_C
;
11008 digest
[3] -= MD5M_D
;
11010 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11012 uint salt_len
= input_len
- 32 - 1;
11014 char *salt_buf
= input_buf
+ 32 + 1;
11016 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11018 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11020 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11022 salt
->salt_len
= salt_len
;
11024 return (PARSER_OK
);
11027 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11029 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11031 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11035 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11038 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11040 salt_t
*salt
= hash_buf
->salt
;
11042 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11043 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11044 digest
[2] = hex_to_uint (&input_buf
[16]);
11045 digest
[3] = hex_to_uint (&input_buf
[24]);
11047 digest
[0] = byte_swap_32 (digest
[0]);
11048 digest
[1] = byte_swap_32 (digest
[1]);
11049 digest
[2] = byte_swap_32 (digest
[2]);
11050 digest
[3] = byte_swap_32 (digest
[3]);
11052 digest
[0] -= MD5M_A
;
11053 digest
[1] -= MD5M_B
;
11054 digest
[2] -= MD5M_C
;
11055 digest
[3] -= MD5M_D
;
11057 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11059 uint salt_len
= input_len
- 32 - 1;
11061 char *salt_buf
= input_buf
+ 32 + 1;
11063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11065 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11067 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11069 salt
->salt_len
= salt_len
;
11071 return (PARSER_OK
);
11074 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11076 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11078 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11080 salt_t
*salt
= hash_buf
->salt
;
11082 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11083 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11084 digest
[2] = hex_to_uint (&input_buf
[16]);
11085 digest
[3] = hex_to_uint (&input_buf
[24]);
11087 digest
[0] = byte_swap_32 (digest
[0]);
11088 digest
[1] = byte_swap_32 (digest
[1]);
11089 digest
[2] = byte_swap_32 (digest
[2]);
11090 digest
[3] = byte_swap_32 (digest
[3]);
11092 digest
[0] -= MD5M_A
;
11093 digest
[1] -= MD5M_B
;
11094 digest
[2] -= MD5M_C
;
11095 digest
[3] -= MD5M_D
;
11098 * This is a virtual salt. While the algorithm is basically not salted
11099 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11100 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11103 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11105 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11107 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11109 salt
->salt_len
= salt_len
;
11111 return (PARSER_OK
);
11114 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11116 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11118 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11122 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11125 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11127 salt_t
*salt
= hash_buf
->salt
;
11129 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11130 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11131 digest
[2] = hex_to_uint (&input_buf
[16]);
11132 digest
[3] = hex_to_uint (&input_buf
[24]);
11134 digest
[0] = byte_swap_32 (digest
[0]);
11135 digest
[1] = byte_swap_32 (digest
[1]);
11136 digest
[2] = byte_swap_32 (digest
[2]);
11137 digest
[3] = byte_swap_32 (digest
[3]);
11139 digest
[0] -= MD5M_A
;
11140 digest
[1] -= MD5M_B
;
11141 digest
[2] -= MD5M_C
;
11142 digest
[3] -= MD5M_D
;
11144 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11146 uint salt_len
= input_len
- 32 - 1;
11148 char *salt_buf
= input_buf
+ 32 + 1;
11150 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11152 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11154 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11156 salt
->salt_len
= salt_len
;
11158 return (PARSER_OK
);
11161 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11163 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11165 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11169 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11172 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11174 salt_t
*salt
= hash_buf
->salt
;
11176 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11177 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11178 digest
[2] = hex_to_uint (&input_buf
[16]);
11179 digest
[3] = hex_to_uint (&input_buf
[24]);
11181 digest
[0] = byte_swap_32 (digest
[0]);
11182 digest
[1] = byte_swap_32 (digest
[1]);
11183 digest
[2] = byte_swap_32 (digest
[2]);
11184 digest
[3] = byte_swap_32 (digest
[3]);
11186 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11188 uint salt_len
= input_len
- 32 - 1;
11190 char *salt_buf
= input_buf
+ 32 + 1;
11192 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11194 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11196 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11198 salt
->salt_len
= salt_len
;
11200 return (PARSER_OK
);
11203 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11205 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11207 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11211 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11214 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11216 salt_t
*salt
= hash_buf
->salt
;
11218 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11219 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11220 digest
[2] = hex_to_uint (&input_buf
[16]);
11221 digest
[3] = hex_to_uint (&input_buf
[24]);
11223 digest
[0] = byte_swap_32 (digest
[0]);
11224 digest
[1] = byte_swap_32 (digest
[1]);
11225 digest
[2] = byte_swap_32 (digest
[2]);
11226 digest
[3] = byte_swap_32 (digest
[3]);
11228 digest
[0] -= MD4M_A
;
11229 digest
[1] -= MD4M_B
;
11230 digest
[2] -= MD4M_C
;
11231 digest
[3] -= MD4M_D
;
11233 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11235 uint salt_len
= input_len
- 32 - 1;
11237 char *salt_buf
= input_buf
+ 32 + 1;
11239 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11241 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11243 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11245 salt
->salt_len
= salt_len
;
11247 return (PARSER_OK
);
11250 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11252 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11254 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11258 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11261 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11263 salt_t
*salt
= hash_buf
->salt
;
11265 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11266 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11267 digest
[2] = hex_to_uint (&input_buf
[16]);
11268 digest
[3] = hex_to_uint (&input_buf
[24]);
11270 digest
[0] = byte_swap_32 (digest
[0]);
11271 digest
[1] = byte_swap_32 (digest
[1]);
11272 digest
[2] = byte_swap_32 (digest
[2]);
11273 digest
[3] = byte_swap_32 (digest
[3]);
11275 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11277 uint salt_len
= input_len
- 32 - 1;
11279 char *salt_buf
= input_buf
+ 32 + 1;
11281 uint salt_pc_block
[16];
11283 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11285 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11287 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11289 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11291 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11293 salt_pc_block
[14] = salt_len
* 8;
11295 uint salt_pc_digest
[4];
11297 salt_pc_digest
[0] = MAGIC_A
;
11298 salt_pc_digest
[1] = MAGIC_B
;
11299 salt_pc_digest
[2] = MAGIC_C
;
11300 salt_pc_digest
[3] = MAGIC_D
;
11302 md5_64 (salt_pc_block
, salt_pc_digest
);
11304 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11305 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11306 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11307 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11309 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11311 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11313 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11315 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11316 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11317 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11318 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11320 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11322 return (PARSER_OK
);
11325 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11327 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11329 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11331 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11332 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11333 digest
[2] = hex_to_uint (&input_buf
[16]);
11334 digest
[3] = hex_to_uint (&input_buf
[24]);
11335 digest
[4] = hex_to_uint (&input_buf
[32]);
11337 digest
[0] -= SHA1M_A
;
11338 digest
[1] -= SHA1M_B
;
11339 digest
[2] -= SHA1M_C
;
11340 digest
[3] -= SHA1M_D
;
11341 digest
[4] -= SHA1M_E
;
11343 return (PARSER_OK
);
11346 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11348 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11350 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11352 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11353 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11354 digest
[2] = hex_to_uint (&input_buf
[16]);
11355 digest
[3] = hex_to_uint (&input_buf
[24]);
11356 digest
[4] = hex_to_uint (&input_buf
[32]);
11358 return (PARSER_OK
);
11361 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11363 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11365 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11369 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11372 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11374 salt_t
*salt
= hash_buf
->salt
;
11376 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11377 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11378 digest
[2] = hex_to_uint (&input_buf
[16]);
11379 digest
[3] = hex_to_uint (&input_buf
[24]);
11380 digest
[4] = hex_to_uint (&input_buf
[32]);
11382 digest
[0] -= SHA1M_A
;
11383 digest
[1] -= SHA1M_B
;
11384 digest
[2] -= SHA1M_C
;
11385 digest
[3] -= SHA1M_D
;
11386 digest
[4] -= SHA1M_E
;
11388 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11390 uint salt_len
= input_len
- 40 - 1;
11392 char *salt_buf
= input_buf
+ 40 + 1;
11394 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11396 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11398 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11400 salt
->salt_len
= salt_len
;
11402 return (PARSER_OK
);
11405 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11407 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11409 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11411 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11415 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11417 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11419 memcpy (digest
, tmp_buf
, 20);
11421 digest
[0] = byte_swap_32 (digest
[0]);
11422 digest
[1] = byte_swap_32 (digest
[1]);
11423 digest
[2] = byte_swap_32 (digest
[2]);
11424 digest
[3] = byte_swap_32 (digest
[3]);
11425 digest
[4] = byte_swap_32 (digest
[4]);
11427 digest
[0] -= SHA1M_A
;
11428 digest
[1] -= SHA1M_B
;
11429 digest
[2] -= SHA1M_C
;
11430 digest
[3] -= SHA1M_D
;
11431 digest
[4] -= SHA1M_E
;
11433 return (PARSER_OK
);
11436 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11438 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11440 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11442 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11444 salt_t
*salt
= hash_buf
->salt
;
11448 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11450 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11452 memcpy (digest
, tmp_buf
, 20);
11454 salt
->salt_len
= tmp_len
- 20;
11456 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11458 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11460 char *ptr
= (char *) salt
->salt_buf
;
11462 ptr
[salt
->salt_len
] = 0x80;
11465 digest
[0] = byte_swap_32 (digest
[0]);
11466 digest
[1] = byte_swap_32 (digest
[1]);
11467 digest
[2] = byte_swap_32 (digest
[2]);
11468 digest
[3] = byte_swap_32 (digest
[3]);
11469 digest
[4] = byte_swap_32 (digest
[4]);
11471 digest
[0] -= SHA1M_A
;
11472 digest
[1] -= SHA1M_B
;
11473 digest
[2] -= SHA1M_C
;
11474 digest
[3] -= SHA1M_D
;
11475 digest
[4] -= SHA1M_E
;
11477 return (PARSER_OK
);
11480 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11482 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11484 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11486 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11488 salt_t
*salt
= hash_buf
->salt
;
11490 char *salt_buf
= input_buf
+ 6;
11494 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11496 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11498 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11500 salt
->salt_len
= salt_len
;
11502 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11504 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11505 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11506 digest
[2] = hex_to_uint (&hash_pos
[16]);
11507 digest
[3] = hex_to_uint (&hash_pos
[24]);
11508 digest
[4] = hex_to_uint (&hash_pos
[32]);
11510 digest
[0] -= SHA1M_A
;
11511 digest
[1] -= SHA1M_B
;
11512 digest
[2] -= SHA1M_C
;
11513 digest
[3] -= SHA1M_D
;
11514 digest
[4] -= SHA1M_E
;
11516 return (PARSER_OK
);
11519 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11521 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11523 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11525 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11527 salt_t
*salt
= hash_buf
->salt
;
11529 char *salt_buf
= input_buf
+ 6;
11533 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11535 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11537 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11539 salt
->salt_len
= salt_len
;
11541 char *hash_pos
= input_buf
+ 6 + 8;
11543 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11544 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11545 digest
[2] = hex_to_uint (&hash_pos
[16]);
11546 digest
[3] = hex_to_uint (&hash_pos
[24]);
11547 digest
[4] = hex_to_uint (&hash_pos
[32]);
11549 digest
[0] -= SHA1M_A
;
11550 digest
[1] -= SHA1M_B
;
11551 digest
[2] -= SHA1M_C
;
11552 digest
[3] -= SHA1M_D
;
11553 digest
[4] -= SHA1M_E
;
11555 return (PARSER_OK
);
11558 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11560 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11562 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11564 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11566 salt_t
*salt
= hash_buf
->salt
;
11568 char *salt_buf
= input_buf
+ 6;
11572 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11574 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11576 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11578 salt
->salt_len
= salt_len
;
11580 char *hash_pos
= input_buf
+ 6 + 8;
11582 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11583 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11584 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11585 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11586 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11587 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11588 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11589 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11591 digest
[0] -= SHA512M_A
;
11592 digest
[1] -= SHA512M_B
;
11593 digest
[2] -= SHA512M_C
;
11594 digest
[3] -= SHA512M_D
;
11595 digest
[4] -= SHA512M_E
;
11596 digest
[5] -= SHA512M_F
;
11597 digest
[6] -= SHA512M_G
;
11598 digest
[7] -= SHA512M_H
;
11600 return (PARSER_OK
);
11603 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11605 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11607 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11611 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11614 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11616 salt_t
*salt
= hash_buf
->salt
;
11618 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11619 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11623 digest
[0] = byte_swap_32 (digest
[0]);
11624 digest
[1] = byte_swap_32 (digest
[1]);
11626 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11628 uint salt_len
= input_len
- 16 - 1;
11630 char *salt_buf
= input_buf
+ 16 + 1;
11632 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11634 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11636 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11638 salt
->salt_len
= salt_len
;
11640 return (PARSER_OK
);
11643 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11645 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11647 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11649 salt_t
*salt
= hash_buf
->salt
;
11651 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11652 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11653 digest
[2] = hex_to_uint (&input_buf
[16]);
11654 digest
[3] = hex_to_uint (&input_buf
[24]);
11655 digest
[4] = hex_to_uint (&input_buf
[32]);
11657 digest
[0] -= SHA1M_A
;
11658 digest
[1] -= SHA1M_B
;
11659 digest
[2] -= SHA1M_C
;
11660 digest
[3] -= SHA1M_D
;
11661 digest
[4] -= SHA1M_E
;
11663 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11665 uint salt_len
= input_len
- 40 - 1;
11667 char *salt_buf
= input_buf
+ 40 + 1;
11669 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11671 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11673 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11675 salt
->salt_len
= salt_len
;
11677 return (PARSER_OK
);
11680 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11682 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11684 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11686 salt_t
*salt
= hash_buf
->salt
;
11688 char *hash_pos
= input_buf
;
11690 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11691 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11692 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11693 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11694 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11695 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11696 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11697 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11698 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11699 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11700 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11701 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11702 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11703 digest
[13] = hex_to_uint (&hash_pos
[104]);
11704 digest
[14] = hex_to_uint (&hash_pos
[112]);
11705 digest
[15] = hex_to_uint (&hash_pos
[120]);
11707 char *salt_pos
= input_buf
+ 128;
11709 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11710 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11711 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11712 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11714 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11715 salt
->salt_len
= 16;
11717 return (PARSER_OK
);
11720 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11722 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11724 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11726 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11727 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11728 digest
[2] = hex_to_uint (&input_buf
[16]);
11729 digest
[3] = hex_to_uint (&input_buf
[24]);
11730 digest
[4] = hex_to_uint (&input_buf
[32]);
11731 digest
[5] = hex_to_uint (&input_buf
[40]);
11732 digest
[6] = hex_to_uint (&input_buf
[48]);
11733 digest
[7] = hex_to_uint (&input_buf
[56]);
11735 digest
[0] -= SHA256M_A
;
11736 digest
[1] -= SHA256M_B
;
11737 digest
[2] -= SHA256M_C
;
11738 digest
[3] -= SHA256M_D
;
11739 digest
[4] -= SHA256M_E
;
11740 digest
[5] -= SHA256M_F
;
11741 digest
[6] -= SHA256M_G
;
11742 digest
[7] -= SHA256M_H
;
11744 return (PARSER_OK
);
11747 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11749 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11751 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11755 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11758 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11760 salt_t
*salt
= hash_buf
->salt
;
11762 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11763 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11764 digest
[2] = hex_to_uint (&input_buf
[16]);
11765 digest
[3] = hex_to_uint (&input_buf
[24]);
11766 digest
[4] = hex_to_uint (&input_buf
[32]);
11767 digest
[5] = hex_to_uint (&input_buf
[40]);
11768 digest
[6] = hex_to_uint (&input_buf
[48]);
11769 digest
[7] = hex_to_uint (&input_buf
[56]);
11771 digest
[0] -= SHA256M_A
;
11772 digest
[1] -= SHA256M_B
;
11773 digest
[2] -= SHA256M_C
;
11774 digest
[3] -= SHA256M_D
;
11775 digest
[4] -= SHA256M_E
;
11776 digest
[5] -= SHA256M_F
;
11777 digest
[6] -= SHA256M_G
;
11778 digest
[7] -= SHA256M_H
;
11780 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11782 uint salt_len
= input_len
- 64 - 1;
11784 char *salt_buf
= input_buf
+ 64 + 1;
11786 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11788 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11790 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11792 salt
->salt_len
= salt_len
;
11794 return (PARSER_OK
);
11797 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11799 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11801 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11803 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11804 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11805 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11806 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11807 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11808 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11812 digest
[0] -= SHA384M_A
;
11813 digest
[1] -= SHA384M_B
;
11814 digest
[2] -= SHA384M_C
;
11815 digest
[3] -= SHA384M_D
;
11816 digest
[4] -= SHA384M_E
;
11817 digest
[5] -= SHA384M_F
;
11821 return (PARSER_OK
);
11824 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11826 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11828 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11830 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11831 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11832 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11833 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11834 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11835 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11836 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11837 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11839 digest
[0] -= SHA512M_A
;
11840 digest
[1] -= SHA512M_B
;
11841 digest
[2] -= SHA512M_C
;
11842 digest
[3] -= SHA512M_D
;
11843 digest
[4] -= SHA512M_E
;
11844 digest
[5] -= SHA512M_F
;
11845 digest
[6] -= SHA512M_G
;
11846 digest
[7] -= SHA512M_H
;
11848 return (PARSER_OK
);
11851 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11853 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11855 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11859 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11862 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11864 salt_t
*salt
= hash_buf
->salt
;
11866 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11867 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11868 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11869 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11870 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11871 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11872 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11873 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11875 digest
[0] -= SHA512M_A
;
11876 digest
[1] -= SHA512M_B
;
11877 digest
[2] -= SHA512M_C
;
11878 digest
[3] -= SHA512M_D
;
11879 digest
[4] -= SHA512M_E
;
11880 digest
[5] -= SHA512M_F
;
11881 digest
[6] -= SHA512M_G
;
11882 digest
[7] -= SHA512M_H
;
11884 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11886 uint salt_len
= input_len
- 128 - 1;
11888 char *salt_buf
= input_buf
+ 128 + 1;
11890 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11892 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11894 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11896 salt
->salt_len
= salt_len
;
11898 return (PARSER_OK
);
11901 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11903 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11905 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11907 salt_t
*salt
= hash_buf
->salt
;
11909 char *salt_pos
= input_buf
+ 3;
11911 uint iterations_len
= 0;
11913 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11917 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11919 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11920 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11924 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11928 iterations_len
+= 8;
11932 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11935 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11937 char *hash_pos
= strchr (salt_pos
, '$');
11939 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11941 uint salt_len
= hash_pos
- salt_pos
;
11943 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11945 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11947 salt
->salt_len
= salt_len
;
11951 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11953 return (PARSER_OK
);
11956 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11958 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11960 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11962 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11964 salt_t
*salt
= hash_buf
->salt
;
11966 uint keccak_mdlen
= input_len
/ 2;
11968 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11970 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11972 digest
[i
] = byte_swap_64 (digest
[i
]);
11975 salt
->keccak_mdlen
= keccak_mdlen
;
11977 return (PARSER_OK
);
11980 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11982 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11984 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11986 salt_t
*salt
= hash_buf
->salt
;
11988 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11991 * Parse that strange long line
11998 in_off
[0] = strtok (input_buf
, ":");
12000 in_len
[0] = strlen (in_off
[0]);
12004 for (i
= 1; i
< 9; i
++)
12006 in_off
[i
] = strtok (NULL
, ":");
12008 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12010 in_len
[i
] = strlen (in_off
[i
]);
12015 ptr
= (char *) ikepsk
->msg_buf
;
12017 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12018 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12019 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12020 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12021 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12022 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12026 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12028 ptr
= (char *) ikepsk
->nr_buf
;
12030 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12031 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12035 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12038 * Store to database
12043 digest
[0] = hex_to_uint (&ptr
[ 0]);
12044 digest
[1] = hex_to_uint (&ptr
[ 8]);
12045 digest
[2] = hex_to_uint (&ptr
[16]);
12046 digest
[3] = hex_to_uint (&ptr
[24]);
12048 digest
[0] = byte_swap_32 (digest
[0]);
12049 digest
[1] = byte_swap_32 (digest
[1]);
12050 digest
[2] = byte_swap_32 (digest
[2]);
12051 digest
[3] = byte_swap_32 (digest
[3]);
12053 salt
->salt_len
= 32;
12055 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12056 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12057 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12058 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12059 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12060 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12061 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12062 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12064 return (PARSER_OK
);
12067 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12069 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12071 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12073 salt_t
*salt
= hash_buf
->salt
;
12075 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12078 * Parse that strange long line
12085 in_off
[0] = strtok (input_buf
, ":");
12087 in_len
[0] = strlen (in_off
[0]);
12091 for (i
= 1; i
< 9; i
++)
12093 in_off
[i
] = strtok (NULL
, ":");
12095 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12097 in_len
[i
] = strlen (in_off
[i
]);
12102 ptr
= (char *) ikepsk
->msg_buf
;
12104 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12105 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12106 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12107 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12108 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12109 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12113 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12115 ptr
= (char *) ikepsk
->nr_buf
;
12117 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12118 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12122 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12125 * Store to database
12130 digest
[0] = hex_to_uint (&ptr
[ 0]);
12131 digest
[1] = hex_to_uint (&ptr
[ 8]);
12132 digest
[2] = hex_to_uint (&ptr
[16]);
12133 digest
[3] = hex_to_uint (&ptr
[24]);
12134 digest
[4] = hex_to_uint (&ptr
[32]);
12136 salt
->salt_len
= 32;
12138 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12139 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12140 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12141 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12142 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12143 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12144 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12145 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12147 return (PARSER_OK
);
12150 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12152 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12154 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12156 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12157 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12158 digest
[2] = hex_to_uint (&input_buf
[16]);
12159 digest
[3] = hex_to_uint (&input_buf
[24]);
12160 digest
[4] = hex_to_uint (&input_buf
[32]);
12162 digest
[0] = byte_swap_32 (digest
[0]);
12163 digest
[1] = byte_swap_32 (digest
[1]);
12164 digest
[2] = byte_swap_32 (digest
[2]);
12165 digest
[3] = byte_swap_32 (digest
[3]);
12166 digest
[4] = byte_swap_32 (digest
[4]);
12168 return (PARSER_OK
);
12171 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12173 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12175 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12177 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12178 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12179 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12180 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12181 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12182 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12183 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12184 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12185 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12186 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12187 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12188 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12189 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12190 digest
[13] = hex_to_uint (&input_buf
[104]);
12191 digest
[14] = hex_to_uint (&input_buf
[112]);
12192 digest
[15] = hex_to_uint (&input_buf
[120]);
12194 return (PARSER_OK
);
12197 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12199 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12201 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12203 salt_t
*salt
= hash_buf
->salt
;
12205 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12206 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12207 digest
[2] = hex_to_uint (&input_buf
[16]);
12208 digest
[3] = hex_to_uint (&input_buf
[24]);
12209 digest
[4] = hex_to_uint (&input_buf
[32]);
12211 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12213 uint salt_len
= input_len
- 40 - 1;
12215 char *salt_buf
= input_buf
+ 40 + 1;
12217 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12219 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12221 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12223 salt
->salt_len
= salt_len
;
12225 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12227 return (PARSER_OK
);
12230 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12232 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12234 salt_t
*salt
= hash_buf
->salt
;
12236 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12238 if (input_len
== 0)
12240 log_error ("TrueCrypt container not specified");
12245 FILE *fp
= fopen (input_buf
, "rb");
12249 log_error ("%s: %s", input_buf
, strerror (errno
));
12256 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12260 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12262 memcpy (tc
->salt_buf
, buf
, 64);
12264 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12266 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12268 salt
->salt_len
= 4;
12270 salt
->salt_iter
= 1000 - 1;
12272 digest
[0] = tc
->data_buf
[0];
12274 return (PARSER_OK
);
12277 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12279 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12281 salt_t
*salt
= hash_buf
->salt
;
12283 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12285 if (input_len
== 0)
12287 log_error ("TrueCrypt container not specified");
12292 FILE *fp
= fopen (input_buf
, "rb");
12296 log_error ("%s: %s", input_buf
, strerror (errno
));
12303 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12307 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12309 memcpy (tc
->salt_buf
, buf
, 64);
12311 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12313 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12315 salt
->salt_len
= 4;
12317 salt
->salt_iter
= 2000 - 1;
12319 digest
[0] = tc
->data_buf
[0];
12321 return (PARSER_OK
);
12324 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12326 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12328 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12330 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12332 salt_t
*salt
= hash_buf
->salt
;
12334 char *salt_pos
= input_buf
+ 6;
12336 char *hash_pos
= strchr (salt_pos
, '$');
12338 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12340 uint salt_len
= hash_pos
- salt_pos
;
12342 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12344 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12346 salt
->salt_len
= salt_len
;
12348 salt
->salt_iter
= 1000;
12352 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12354 return (PARSER_OK
);
12357 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12359 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12361 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12363 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12365 salt_t
*salt
= hash_buf
->salt
;
12367 char *iter_pos
= input_buf
+ 7;
12369 char *salt_pos
= strchr (iter_pos
, '$');
12371 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12375 char *hash_pos
= strchr (salt_pos
, '$');
12377 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12379 uint salt_len
= hash_pos
- salt_pos
;
12381 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12383 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12385 salt
->salt_len
= salt_len
;
12387 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12389 salt
->salt_sign
[0] = atoi (salt_iter
);
12391 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12395 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12397 digest
[0] = byte_swap_32 (digest
[0]);
12398 digest
[1] = byte_swap_32 (digest
[1]);
12399 digest
[2] = byte_swap_32 (digest
[2]);
12400 digest
[3] = byte_swap_32 (digest
[3]);
12401 digest
[4] = byte_swap_32 (digest
[4]);
12403 return (PARSER_OK
);
12406 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12408 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12410 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12412 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12414 salt_t
*salt
= hash_buf
->salt
;
12416 char *iter_pos
= input_buf
+ 9;
12418 char *salt_pos
= strchr (iter_pos
, '$');
12420 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12424 char *hash_pos
= strchr (salt_pos
, '$');
12426 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12428 uint salt_len
= hash_pos
- salt_pos
;
12430 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12432 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12434 salt
->salt_len
= salt_len
;
12436 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12438 salt
->salt_sign
[0] = atoi (salt_iter
);
12440 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12444 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12446 digest
[0] = byte_swap_32 (digest
[0]);
12447 digest
[1] = byte_swap_32 (digest
[1]);
12448 digest
[2] = byte_swap_32 (digest
[2]);
12449 digest
[3] = byte_swap_32 (digest
[3]);
12450 digest
[4] = byte_swap_32 (digest
[4]);
12451 digest
[5] = byte_swap_32 (digest
[5]);
12452 digest
[6] = byte_swap_32 (digest
[6]);
12453 digest
[7] = byte_swap_32 (digest
[7]);
12455 return (PARSER_OK
);
12458 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12460 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12462 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12464 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12466 salt_t
*salt
= hash_buf
->salt
;
12468 char *iter_pos
= input_buf
+ 9;
12470 char *salt_pos
= strchr (iter_pos
, '$');
12472 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12476 char *hash_pos
= strchr (salt_pos
, '$');
12478 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12480 uint salt_len
= hash_pos
- salt_pos
;
12482 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12484 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12486 salt
->salt_len
= salt_len
;
12488 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12490 salt
->salt_sign
[0] = atoi (salt_iter
);
12492 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12496 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12498 digest
[0] = byte_swap_64 (digest
[0]);
12499 digest
[1] = byte_swap_64 (digest
[1]);
12500 digest
[2] = byte_swap_64 (digest
[2]);
12501 digest
[3] = byte_swap_64 (digest
[3]);
12502 digest
[4] = byte_swap_64 (digest
[4]);
12503 digest
[5] = byte_swap_64 (digest
[5]);
12504 digest
[6] = byte_swap_64 (digest
[6]);
12505 digest
[7] = byte_swap_64 (digest
[7]);
12507 return (PARSER_OK
);
12510 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12512 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12514 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12516 salt_t
*salt
= hash_buf
->salt
;
12518 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12524 char *iterations_pos
= input_buf
;
12526 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12528 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12530 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12532 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12536 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12538 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12540 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12542 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12544 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12546 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12551 * pbkdf2 iterations
12554 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12557 * handle salt encoding
12560 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12562 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12564 const char p0
= saltbuf_pos
[i
+ 0];
12565 const char p1
= saltbuf_pos
[i
+ 1];
12567 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12568 | hex_convert (p0
) << 4;
12571 salt
->salt_len
= saltbuf_len
/ 2;
12574 * handle cipher encoding
12577 uint
*tmp
= (uint
*) mymalloc (32);
12579 char *cipherbuf_ptr
= (char *) tmp
;
12581 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12583 const char p0
= cipherbuf_pos
[i
+ 0];
12584 const char p1
= cipherbuf_pos
[i
+ 1];
12586 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12587 | hex_convert (p0
) << 4;
12590 // iv is stored at salt_buf 4 (length 16)
12591 // data is stored at salt_buf 8 (length 16)
12593 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12594 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12595 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12596 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12598 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12599 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12600 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12601 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12605 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12607 const char p0
= cipherbuf_pos
[j
+ 0];
12608 const char p1
= cipherbuf_pos
[j
+ 1];
12610 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12611 | hex_convert (p0
) << 4;
12618 digest
[0] = 0x10101010;
12619 digest
[1] = 0x10101010;
12620 digest
[2] = 0x10101010;
12621 digest
[3] = 0x10101010;
12623 return (PARSER_OK
);
12626 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12628 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12630 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12632 salt_t
*salt
= hash_buf
->salt
;
12634 char *hashbuf_pos
= input_buf
;
12636 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12638 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12640 uint hash_len
= iterations_pos
- hashbuf_pos
;
12642 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12646 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12648 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12650 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12654 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12656 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12658 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12660 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12662 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12664 salt
->salt_len
= salt_len
;
12666 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12668 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12669 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12670 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12671 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12673 return (PARSER_OK
);
12676 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12678 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12680 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12682 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12683 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12684 digest
[2] = hex_to_uint (&input_buf
[16]);
12685 digest
[3] = hex_to_uint (&input_buf
[24]);
12686 digest
[4] = hex_to_uint (&input_buf
[32]);
12687 digest
[5] = hex_to_uint (&input_buf
[40]);
12688 digest
[6] = hex_to_uint (&input_buf
[48]);
12689 digest
[7] = hex_to_uint (&input_buf
[56]);
12691 digest
[0] = byte_swap_32 (digest
[0]);
12692 digest
[1] = byte_swap_32 (digest
[1]);
12693 digest
[2] = byte_swap_32 (digest
[2]);
12694 digest
[3] = byte_swap_32 (digest
[3]);
12695 digest
[4] = byte_swap_32 (digest
[4]);
12696 digest
[5] = byte_swap_32 (digest
[5]);
12697 digest
[6] = byte_swap_32 (digest
[6]);
12698 digest
[7] = byte_swap_32 (digest
[7]);
12700 return (PARSER_OK
);
12703 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12705 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12707 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12709 salt_t
*salt
= hash_buf
->salt
;
12711 char *salt_pos
= input_buf
+ 3;
12713 uint iterations_len
= 0;
12715 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12719 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12721 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12722 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12726 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12730 iterations_len
+= 8;
12734 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12737 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12739 char *hash_pos
= strchr (salt_pos
, '$');
12741 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12743 uint salt_len
= hash_pos
- salt_pos
;
12745 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12747 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12749 salt
->salt_len
= salt_len
;
12753 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12755 return (PARSER_OK
);
12758 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12760 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12762 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12764 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12766 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12768 salt_t
*salt
= hash_buf
->salt
;
12770 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12772 char *iter_pos
= input_buf
+ 4;
12774 char *salt_pos
= strchr (iter_pos
, '$');
12776 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12780 char *hash_pos
= strchr (salt_pos
, '$');
12782 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12784 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12788 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12789 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12790 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12791 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12792 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12793 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12794 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12795 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12797 uint salt_len
= hash_pos
- salt_pos
- 1;
12799 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12801 salt
->salt_len
= salt_len
/ 2;
12803 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12804 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12805 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12806 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12807 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12808 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12809 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12810 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12812 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12813 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12814 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12815 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12816 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12817 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12818 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12819 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12820 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12821 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12823 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12825 salt
->salt_iter
= atoi (iter_pos
) - 1;
12827 return (PARSER_OK
);
12830 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12832 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12834 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12836 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12838 salt_t
*salt
= hash_buf
->salt
;
12840 char *salt_pos
= input_buf
+ 14;
12842 char *hash_pos
= strchr (salt_pos
, '*');
12844 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12848 uint salt_len
= hash_pos
- salt_pos
- 1;
12850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12852 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12854 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12856 salt
->salt_len
= salt_len
;
12858 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12860 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12862 memcpy (digest
, tmp_buf
, 32);
12864 digest
[0] = byte_swap_32 (digest
[0]);
12865 digest
[1] = byte_swap_32 (digest
[1]);
12866 digest
[2] = byte_swap_32 (digest
[2]);
12867 digest
[3] = byte_swap_32 (digest
[3]);
12868 digest
[4] = byte_swap_32 (digest
[4]);
12869 digest
[5] = byte_swap_32 (digest
[5]);
12870 digest
[6] = byte_swap_32 (digest
[6]);
12871 digest
[7] = byte_swap_32 (digest
[7]);
12873 digest
[0] -= SHA256M_A
;
12874 digest
[1] -= SHA256M_B
;
12875 digest
[2] -= SHA256M_C
;
12876 digest
[3] -= SHA256M_D
;
12877 digest
[4] -= SHA256M_E
;
12878 digest
[5] -= SHA256M_F
;
12879 digest
[6] -= SHA256M_G
;
12880 digest
[7] -= SHA256M_H
;
12882 return (PARSER_OK
);
12885 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12887 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12889 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12891 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12893 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12895 salt_t
*salt
= hash_buf
->salt
;
12897 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12899 char *iter_pos
= input_buf
+ 19;
12901 char *salt_pos
= strchr (iter_pos
, '.');
12903 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12907 char *hash_pos
= strchr (salt_pos
, '.');
12909 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12911 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12915 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12916 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12917 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12918 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12919 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12920 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12921 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12922 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12924 uint salt_len
= hash_pos
- salt_pos
- 1;
12928 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12932 for (i
= 0; i
< salt_len
; i
++)
12934 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12937 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12938 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12940 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12942 salt
->salt_len
= salt_len
;
12944 salt
->salt_iter
= atoi (iter_pos
) - 1;
12946 return (PARSER_OK
);
12949 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12951 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12953 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12955 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12957 salt_t
*salt
= hash_buf
->salt
;
12961 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12963 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12965 memcpy (digest
, tmp_buf
, 64);
12967 digest
[0] = byte_swap_64 (digest
[0]);
12968 digest
[1] = byte_swap_64 (digest
[1]);
12969 digest
[2] = byte_swap_64 (digest
[2]);
12970 digest
[3] = byte_swap_64 (digest
[3]);
12971 digest
[4] = byte_swap_64 (digest
[4]);
12972 digest
[5] = byte_swap_64 (digest
[5]);
12973 digest
[6] = byte_swap_64 (digest
[6]);
12974 digest
[7] = byte_swap_64 (digest
[7]);
12976 digest
[0] -= SHA512M_A
;
12977 digest
[1] -= SHA512M_B
;
12978 digest
[2] -= SHA512M_C
;
12979 digest
[3] -= SHA512M_D
;
12980 digest
[4] -= SHA512M_E
;
12981 digest
[5] -= SHA512M_F
;
12982 digest
[6] -= SHA512M_G
;
12983 digest
[7] -= SHA512M_H
;
12985 salt
->salt_len
= tmp_len
- 64;
12987 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12989 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12991 char *ptr
= (char *) salt
->salt_buf
;
12993 ptr
[salt
->salt_len
] = 0x80;
12996 return (PARSER_OK
);
12999 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13001 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13003 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13007 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13010 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13012 salt_t
*salt
= hash_buf
->salt
;
13014 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13015 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13016 digest
[2] = hex_to_uint (&input_buf
[16]);
13017 digest
[3] = hex_to_uint (&input_buf
[24]);
13019 digest
[0] = byte_swap_32 (digest
[0]);
13020 digest
[1] = byte_swap_32 (digest
[1]);
13021 digest
[2] = byte_swap_32 (digest
[2]);
13022 digest
[3] = byte_swap_32 (digest
[3]);
13024 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13026 uint salt_len
= input_len
- 32 - 1;
13028 char *salt_buf
= input_buf
+ 32 + 1;
13030 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13032 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13036 salt
->salt_len
= salt_len
;
13038 return (PARSER_OK
);
13041 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13043 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13045 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13049 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13052 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13054 salt_t
*salt
= hash_buf
->salt
;
13056 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13057 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13058 digest
[2] = hex_to_uint (&input_buf
[16]);
13059 digest
[3] = hex_to_uint (&input_buf
[24]);
13060 digest
[4] = hex_to_uint (&input_buf
[32]);
13062 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13064 uint salt_len
= input_len
- 40 - 1;
13066 char *salt_buf
= input_buf
+ 40 + 1;
13068 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13070 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13072 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13074 salt
->salt_len
= salt_len
;
13076 return (PARSER_OK
);
13079 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13081 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13083 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13087 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13090 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13092 salt_t
*salt
= hash_buf
->salt
;
13094 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13095 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13096 digest
[2] = hex_to_uint (&input_buf
[16]);
13097 digest
[3] = hex_to_uint (&input_buf
[24]);
13098 digest
[4] = hex_to_uint (&input_buf
[32]);
13099 digest
[5] = hex_to_uint (&input_buf
[40]);
13100 digest
[6] = hex_to_uint (&input_buf
[48]);
13101 digest
[7] = hex_to_uint (&input_buf
[56]);
13103 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13105 uint salt_len
= input_len
- 64 - 1;
13107 char *salt_buf
= input_buf
+ 64 + 1;
13109 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13111 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13113 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13115 salt
->salt_len
= salt_len
;
13117 return (PARSER_OK
);
13120 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13122 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13124 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13128 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13131 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13133 salt_t
*salt
= hash_buf
->salt
;
13135 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13136 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13137 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13138 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13139 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13140 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13141 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13142 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13144 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13146 uint salt_len
= input_len
- 128 - 1;
13148 char *salt_buf
= input_buf
+ 128 + 1;
13150 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13152 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13154 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13156 salt
->salt_len
= salt_len
;
13158 return (PARSER_OK
);
13161 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13163 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13165 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13167 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13169 salt_t
*salt
= hash_buf
->salt
;
13171 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13177 char *user_pos
= input_buf
+ 10 + 1;
13179 char *realm_pos
= strchr (user_pos
, '$');
13181 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13183 uint user_len
= realm_pos
- user_pos
;
13185 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13189 char *salt_pos
= strchr (realm_pos
, '$');
13191 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13193 uint realm_len
= salt_pos
- realm_pos
;
13195 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13199 char *data_pos
= strchr (salt_pos
, '$');
13201 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13203 uint salt_len
= data_pos
- salt_pos
;
13205 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13209 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13211 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13217 memcpy (krb5pa
->user
, user_pos
, user_len
);
13218 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13219 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13221 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13223 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13225 const char p0
= data_pos
[i
+ 0];
13226 const char p1
= data_pos
[i
+ 1];
13228 *timestamp_ptr
++ = hex_convert (p1
) << 0
13229 | hex_convert (p0
) << 4;
13232 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13234 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13236 const char p0
= data_pos
[i
+ 0];
13237 const char p1
= data_pos
[i
+ 1];
13239 *checksum_ptr
++ = hex_convert (p1
) << 0
13240 | hex_convert (p0
) << 4;
13244 * copy some data to generic buffers to make sorting happy
13247 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13248 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13249 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13250 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13251 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13252 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13253 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13254 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13255 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13257 salt
->salt_len
= 36;
13259 digest
[0] = krb5pa
->checksum
[0];
13260 digest
[1] = krb5pa
->checksum
[1];
13261 digest
[2] = krb5pa
->checksum
[2];
13262 digest
[3] = krb5pa
->checksum
[3];
13264 return (PARSER_OK
);
13267 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13269 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13271 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13273 salt_t
*salt
= hash_buf
->salt
;
13279 char *salt_pos
= input_buf
;
13281 char *hash_pos
= strchr (salt_pos
, '$');
13283 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13285 uint salt_len
= hash_pos
- salt_pos
;
13287 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13291 uint hash_len
= input_len
- 1 - salt_len
;
13293 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13301 for (uint i
= 0; i
< salt_len
; i
++)
13303 if (salt_pos
[i
] == ' ') continue;
13308 // SAP user names cannot be longer than 12 characters
13309 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13311 // SAP user name cannot start with ! or ?
13312 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13324 salt
->salt_len
= salt_len
;
13326 digest
[0] = hex_to_uint (&hash_pos
[0]);
13327 digest
[1] = hex_to_uint (&hash_pos
[8]);
13331 digest
[0] = byte_swap_32 (digest
[0]);
13332 digest
[1] = byte_swap_32 (digest
[1]);
13334 return (PARSER_OK
);
13337 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13339 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13341 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13343 salt_t
*salt
= hash_buf
->salt
;
13349 char *salt_pos
= input_buf
;
13351 char *hash_pos
= strchr (salt_pos
, '$');
13353 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13355 uint salt_len
= hash_pos
- salt_pos
;
13357 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13361 uint hash_len
= input_len
- 1 - salt_len
;
13363 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13371 for (uint i
= 0; i
< salt_len
; i
++)
13373 if (salt_pos
[i
] == ' ') continue;
13378 // SAP user names cannot be longer than 12 characters
13379 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13380 // so far nobody complained so we stay with this because it helps in optimization
13381 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13383 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13385 // SAP user name cannot start with ! or ?
13386 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13392 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13394 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13396 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13398 salt
->salt_len
= salt_len
;
13400 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13401 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13402 digest
[2] = hex_to_uint (&hash_pos
[16]);
13403 digest
[3] = hex_to_uint (&hash_pos
[24]);
13404 digest
[4] = hex_to_uint (&hash_pos
[32]);
13406 return (PARSER_OK
);
13409 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13411 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13413 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13415 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13417 salt_t
*salt
= hash_buf
->salt
;
13419 char *iter_pos
= input_buf
+ 3;
13421 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13423 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13425 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13427 salt
->salt_iter
= salt_iter
;
13429 char *salt_pos
= iter_pos
+ 1;
13433 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13435 salt
->salt_len
= salt_len
;
13437 char *hash_pos
= salt_pos
+ salt_len
;
13439 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13443 char *tmp
= (char *) salt
->salt_buf_pc
;
13445 tmp
[0] = hash_pos
[42];
13449 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13450 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13451 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13452 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13458 return (PARSER_OK
);
13461 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13463 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13465 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13467 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13469 salt_t
*salt
= hash_buf
->salt
;
13471 char *salt_buf
= input_buf
+ 6;
13473 uint salt_len
= 16;
13475 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13477 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13479 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13481 salt
->salt_len
= salt_len
;
13483 char *hash_pos
= input_buf
+ 6 + 16;
13485 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13486 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13487 digest
[2] = hex_to_uint (&hash_pos
[16]);
13488 digest
[3] = hex_to_uint (&hash_pos
[24]);
13489 digest
[4] = hex_to_uint (&hash_pos
[32]);
13490 digest
[5] = hex_to_uint (&hash_pos
[40]);
13491 digest
[6] = hex_to_uint (&hash_pos
[48]);
13492 digest
[7] = hex_to_uint (&hash_pos
[56]);
13494 return (PARSER_OK
);
13497 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13499 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13501 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13503 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13504 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13508 return (PARSER_OK
);
13511 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13513 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13515 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13517 salt_t
*salt
= hash_buf
->salt
;
13519 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13521 char *saltbuf_pos
= input_buf
;
13523 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13525 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13527 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13529 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13530 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13532 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13536 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13538 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13540 char *salt_ptr
= (char *) saltbuf_pos
;
13541 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13546 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13548 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13551 rakp_ptr
[j
] = 0x80;
13553 rakp
->salt_len
= j
;
13555 for (i
= 0; i
< 64; i
++)
13557 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13560 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13561 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13562 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13563 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13564 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13565 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13566 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13567 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13569 salt
->salt_len
= 32; // muss min. 32 haben
13571 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13572 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13573 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13574 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13575 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13577 return (PARSER_OK
);
13580 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13582 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13584 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13586 salt_t
*salt
= hash_buf
->salt
;
13588 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13590 char *salt_pos
= input_buf
+ 1;
13592 memcpy (salt
->salt_buf
, salt_pos
, 8);
13594 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13595 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13597 salt
->salt_len
= 8;
13599 char *hash_pos
= salt_pos
+ 8;
13601 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13602 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13603 digest
[2] = hex_to_uint (&hash_pos
[16]);
13604 digest
[3] = hex_to_uint (&hash_pos
[24]);
13605 digest
[4] = hex_to_uint (&hash_pos
[32]);
13607 digest
[0] -= SHA1M_A
;
13608 digest
[1] -= SHA1M_B
;
13609 digest
[2] -= SHA1M_C
;
13610 digest
[3] -= SHA1M_D
;
13611 digest
[4] -= SHA1M_E
;
13613 return (PARSER_OK
);
13616 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13618 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13620 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13622 salt_t
*salt
= hash_buf
->salt
;
13624 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13625 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13626 digest
[2] = hex_to_uint (&input_buf
[16]);
13627 digest
[3] = hex_to_uint (&input_buf
[24]);
13629 digest
[0] = byte_swap_32 (digest
[0]);
13630 digest
[1] = byte_swap_32 (digest
[1]);
13631 digest
[2] = byte_swap_32 (digest
[2]);
13632 digest
[3] = byte_swap_32 (digest
[3]);
13634 digest
[0] -= MD5M_A
;
13635 digest
[1] -= MD5M_B
;
13636 digest
[2] -= MD5M_C
;
13637 digest
[3] -= MD5M_D
;
13639 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13641 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13643 uint32_t *salt_buf
= salt
->salt_buf
;
13645 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13646 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13647 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13648 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13650 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13651 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13652 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13653 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13655 salt
->salt_len
= 16 + 1;
13657 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13659 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13661 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13663 return (PARSER_OK
);
13666 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13668 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13670 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13672 salt_t
*salt
= hash_buf
->salt
;
13674 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13680 char *hashbuf_pos
= input_buf
;
13682 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13684 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13686 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13688 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13692 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13694 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13696 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13698 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13702 char *databuf_pos
= strchr (iteration_pos
, ':');
13704 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13706 const uint iteration_len
= databuf_pos
- iteration_pos
;
13708 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13709 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13711 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13713 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13714 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13720 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13721 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13722 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13723 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13724 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13725 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13726 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13727 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13731 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13733 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13735 const char p0
= saltbuf_pos
[i
+ 0];
13736 const char p1
= saltbuf_pos
[i
+ 1];
13738 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13739 | hex_convert (p0
) << 4;
13742 salt
->salt_buf
[4] = 0x01000000;
13743 salt
->salt_buf
[5] = 0x80;
13745 salt
->salt_len
= saltbuf_len
/ 2;
13749 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13753 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13755 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13757 const char p0
= databuf_pos
[i
+ 0];
13758 const char p1
= databuf_pos
[i
+ 1];
13760 *databuf_ptr
++ = hex_convert (p1
) << 0
13761 | hex_convert (p0
) << 4;
13764 *databuf_ptr
++ = 0x80;
13766 for (uint i
= 0; i
< 512; i
++)
13768 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13771 cloudkey
->data_len
= databuf_len
/ 2;
13773 return (PARSER_OK
);
13776 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13778 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13780 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13782 salt_t
*salt
= hash_buf
->salt
;
13788 char *hashbuf_pos
= input_buf
;
13790 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13792 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13794 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13796 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13800 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13802 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13804 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13806 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13808 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13812 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13814 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13816 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13818 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13820 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13824 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13826 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13827 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13829 // ok, the plan for this algorithm is the following:
13830 // we have 2 salts here, the domain-name and a random salt
13831 // while both are used in the initial transformation,
13832 // only the random salt is used in the following iterations
13833 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13834 // and one that includes only the real salt (stored into salt_buf[]).
13835 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13837 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13839 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13841 memcpy (digest
, tmp_buf
, 20);
13843 digest
[0] = byte_swap_32 (digest
[0]);
13844 digest
[1] = byte_swap_32 (digest
[1]);
13845 digest
[2] = byte_swap_32 (digest
[2]);
13846 digest
[3] = byte_swap_32 (digest
[3]);
13847 digest
[4] = byte_swap_32 (digest
[4]);
13851 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13853 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13855 char *len_ptr
= NULL
;
13857 for (uint i
= 0; i
< domainbuf_len
; i
++)
13859 if (salt_buf_pc_ptr
[i
] == '.')
13861 len_ptr
= &salt_buf_pc_ptr
[i
];
13871 salt
->salt_buf_pc
[7] = domainbuf_len
;
13875 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13877 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13879 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13881 salt
->salt_len
= salt_len
;
13885 salt
->salt_iter
= atoi (iteration_pos
);
13887 return (PARSER_OK
);
13890 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13892 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13894 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13896 salt_t
*salt
= hash_buf
->salt
;
13898 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13899 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13900 digest
[2] = hex_to_uint (&input_buf
[16]);
13901 digest
[3] = hex_to_uint (&input_buf
[24]);
13902 digest
[4] = hex_to_uint (&input_buf
[32]);
13904 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13906 uint salt_len
= input_len
- 40 - 1;
13908 char *salt_buf
= input_buf
+ 40 + 1;
13910 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13912 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13914 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13916 salt
->salt_len
= salt_len
;
13918 return (PARSER_OK
);
13921 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13923 const uint8_t ascii_to_ebcdic
[] =
13925 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13926 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13927 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13928 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13929 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13930 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13931 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13932 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13933 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13934 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13935 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13936 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13937 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13938 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13939 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13940 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13943 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13945 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13947 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13949 salt_t
*salt
= hash_buf
->salt
;
13951 char *salt_pos
= input_buf
+ 6 + 1;
13953 char *digest_pos
= strchr (salt_pos
, '*');
13955 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13957 uint salt_len
= digest_pos
- salt_pos
;
13959 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13961 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13963 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13967 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13968 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13970 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13972 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13974 salt
->salt_len
= salt_len
;
13976 for (uint i
= 0; i
< salt_len
; i
++)
13978 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13980 for (uint i
= salt_len
; i
< 8; i
++)
13982 salt_buf_pc_ptr
[i
] = 0x40;
13987 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13989 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13990 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13992 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13993 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13995 digest
[0] = byte_swap_32 (digest
[0]);
13996 digest
[1] = byte_swap_32 (digest
[1]);
13998 IP (digest
[0], digest
[1], tt
);
14000 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
14001 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
14005 return (PARSER_OK
);
14008 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14010 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14012 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14014 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14015 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14016 digest
[2] = hex_to_uint (&input_buf
[16]);
14017 digest
[3] = hex_to_uint (&input_buf
[24]);
14019 digest
[0] = byte_swap_32 (digest
[0]);
14020 digest
[1] = byte_swap_32 (digest
[1]);
14021 digest
[2] = byte_swap_32 (digest
[2]);
14022 digest
[3] = byte_swap_32 (digest
[3]);
14024 return (PARSER_OK
);
14027 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14029 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14031 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14033 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14035 salt_t
*salt
= hash_buf
->salt
;
14039 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14041 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14043 tmp_buf
[3] += -4; // dont ask!
14045 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14047 salt
->salt_len
= 5;
14049 memcpy (digest
, tmp_buf
+ 5, 9);
14051 // yes, only 9 byte are needed to crack, but 10 to display
14053 salt
->salt_buf_pc
[7] = input_buf
[20];
14055 return (PARSER_OK
);
14058 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14060 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14062 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14064 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14066 salt_t
*salt
= hash_buf
->salt
;
14070 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14072 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14074 tmp_buf
[3] += -4; // dont ask!
14078 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14080 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)
14084 char tmp_iter_buf
[11];
14086 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14088 tmp_iter_buf
[10] = 0;
14090 salt
->salt_iter
= atoi (tmp_iter_buf
);
14092 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14094 return (PARSER_SALT_ITERATION
);
14097 salt
->salt_iter
--; // first round in init
14099 // 2 additional bytes for display only
14101 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14102 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14106 memcpy (digest
, tmp_buf
+ 28, 8);
14108 digest
[0] = byte_swap_32 (digest
[0]);
14109 digest
[1] = byte_swap_32 (digest
[1]);
14113 return (PARSER_OK
);
14116 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14118 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14120 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14122 salt_t
*salt
= hash_buf
->salt
;
14124 char *salt_buf_pos
= input_buf
;
14126 char *hash_buf_pos
= salt_buf_pos
+ 6;
14128 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14129 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14130 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14131 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14132 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14133 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14134 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14135 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14137 digest
[0] -= SHA256M_A
;
14138 digest
[1] -= SHA256M_B
;
14139 digest
[2] -= SHA256M_C
;
14140 digest
[3] -= SHA256M_D
;
14141 digest
[4] -= SHA256M_E
;
14142 digest
[5] -= SHA256M_F
;
14143 digest
[6] -= SHA256M_G
;
14144 digest
[7] -= SHA256M_H
;
14146 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14148 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14150 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14152 salt
->salt_len
= salt_len
;
14154 return (PARSER_OK
);
14157 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14159 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14161 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14163 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14165 salt_t
*salt
= hash_buf
->salt
;
14167 char *salt_buf
= input_buf
+ 6;
14169 char *digest_buf
= strchr (salt_buf
, '$');
14171 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14173 uint salt_len
= digest_buf
- salt_buf
;
14175 digest_buf
++; // skip the '$' symbol
14177 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14179 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14181 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14183 salt
->salt_len
= salt_len
;
14185 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14186 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14187 digest
[2] = hex_to_uint (&digest_buf
[16]);
14188 digest
[3] = hex_to_uint (&digest_buf
[24]);
14190 digest
[0] = byte_swap_32 (digest
[0]);
14191 digest
[1] = byte_swap_32 (digest
[1]);
14192 digest
[2] = byte_swap_32 (digest
[2]);
14193 digest
[3] = byte_swap_32 (digest
[3]);
14195 digest
[0] -= MD5M_A
;
14196 digest
[1] -= MD5M_B
;
14197 digest
[2] -= MD5M_C
;
14198 digest
[3] -= MD5M_D
;
14200 return (PARSER_OK
);
14203 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14205 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14207 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14209 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14211 salt_t
*salt
= hash_buf
->salt
;
14213 char *salt_buf
= input_buf
+ 3;
14215 char *digest_buf
= strchr (salt_buf
, '$');
14217 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14219 uint salt_len
= digest_buf
- salt_buf
;
14221 digest_buf
++; // skip the '$' symbol
14223 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14225 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14227 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14229 salt_buf_ptr
[salt_len
] = 0x2d;
14231 salt
->salt_len
= salt_len
+ 1;
14233 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14234 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14235 digest
[2] = hex_to_uint (&digest_buf
[16]);
14236 digest
[3] = hex_to_uint (&digest_buf
[24]);
14238 digest
[0] = byte_swap_32 (digest
[0]);
14239 digest
[1] = byte_swap_32 (digest
[1]);
14240 digest
[2] = byte_swap_32 (digest
[2]);
14241 digest
[3] = byte_swap_32 (digest
[3]);
14243 digest
[0] -= MD5M_A
;
14244 digest
[1] -= MD5M_B
;
14245 digest
[2] -= MD5M_C
;
14246 digest
[3] -= MD5M_D
;
14248 return (PARSER_OK
);
14251 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14253 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14255 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14259 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14261 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14263 memcpy (digest
, tmp_buf
, 20);
14265 digest
[0] = byte_swap_32 (digest
[0]);
14266 digest
[1] = byte_swap_32 (digest
[1]);
14267 digest
[2] = byte_swap_32 (digest
[2]);
14268 digest
[3] = byte_swap_32 (digest
[3]);
14269 digest
[4] = byte_swap_32 (digest
[4]);
14271 digest
[0] -= SHA1M_A
;
14272 digest
[1] -= SHA1M_B
;
14273 digest
[2] -= SHA1M_C
;
14274 digest
[3] -= SHA1M_D
;
14275 digest
[4] -= SHA1M_E
;
14277 return (PARSER_OK
);
14280 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14282 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14284 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14286 salt_t
*salt
= hash_buf
->salt
;
14288 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14289 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14290 digest
[2] = hex_to_uint (&input_buf
[16]);
14291 digest
[3] = hex_to_uint (&input_buf
[24]);
14293 digest
[0] = byte_swap_32 (digest
[0]);
14294 digest
[1] = byte_swap_32 (digest
[1]);
14295 digest
[2] = byte_swap_32 (digest
[2]);
14296 digest
[3] = byte_swap_32 (digest
[3]);
14298 digest
[0] -= MD5M_A
;
14299 digest
[1] -= MD5M_B
;
14300 digest
[2] -= MD5M_C
;
14301 digest
[3] -= MD5M_D
;
14303 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14305 uint salt_len
= input_len
- 32 - 1;
14307 char *salt_buf
= input_buf
+ 32 + 1;
14309 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14311 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14313 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14316 * add static "salt" part
14319 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14323 salt
->salt_len
= salt_len
;
14325 return (PARSER_OK
);
14328 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14330 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14332 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14334 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14336 salt_t
*salt
= hash_buf
->salt
;
14338 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14344 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14346 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14348 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14350 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14352 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14356 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14358 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14360 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14362 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14366 char *keybuf_pos
= strchr (keylen_pos
, '$');
14368 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14370 uint keylen_len
= keybuf_pos
- keylen_pos
;
14372 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14376 char *databuf_pos
= strchr (keybuf_pos
, '$');
14378 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14380 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14382 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14386 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14388 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14394 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14395 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14396 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14397 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14399 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14400 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14401 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14402 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14404 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14405 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14406 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14407 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14409 salt
->salt_len
= 16;
14410 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14412 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14414 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14417 return (PARSER_OK
);
14420 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14422 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14424 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14426 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14428 salt_t
*salt
= hash_buf
->salt
;
14434 // first is the N salt parameter
14436 char *N_pos
= input_buf
+ 6;
14438 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14442 salt
->scrypt_N
= atoi (N_pos
);
14446 char *r_pos
= strchr (N_pos
, ':');
14448 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14452 salt
->scrypt_r
= atoi (r_pos
);
14456 char *p_pos
= strchr (r_pos
, ':');
14458 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14462 salt
->scrypt_p
= atoi (p_pos
);
14466 char *saltbuf_pos
= strchr (p_pos
, ':');
14468 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14472 char *hash_pos
= strchr (saltbuf_pos
, ':');
14474 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14482 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14484 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14486 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14488 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14490 salt
->salt_len
= tmp_len
;
14491 salt
->salt_iter
= 1;
14493 // digest - base64 decode
14495 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14497 tmp_len
= input_len
- (hash_pos
- input_buf
);
14499 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14501 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14503 memcpy (digest
, tmp_buf
, 32);
14505 return (PARSER_OK
);
14508 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14510 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14512 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14514 salt_t
*salt
= hash_buf
->salt
;
14520 char decrypted
[76]; // iv + hash
14522 juniper_decrypt_hash (input_buf
, decrypted
);
14524 char *md5crypt_hash
= decrypted
+ 12;
14526 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14528 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14530 char *salt_pos
= md5crypt_hash
+ 3;
14532 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14534 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14536 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14540 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14542 return (PARSER_OK
);
14545 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14547 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14549 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14551 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14553 salt_t
*salt
= hash_buf
->salt
;
14555 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14561 // first is *raw* salt
14563 char *salt_pos
= input_buf
+ 3;
14565 char *hash_pos
= strchr (salt_pos
, '$');
14567 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14569 uint salt_len
= hash_pos
- salt_pos
;
14571 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14575 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14577 memcpy (salt_buf_ptr
, salt_pos
, 14);
14579 salt_buf_ptr
[17] = 0x01;
14580 salt_buf_ptr
[18] = 0x80;
14582 // add some stuff to normal salt to make sorted happy
14584 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14585 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14586 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14587 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14589 salt
->salt_len
= salt_len
;
14590 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14592 // base64 decode hash
14596 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14598 uint hash_len
= input_len
- 3 - salt_len
- 1;
14600 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14602 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14604 memcpy (digest
, tmp_buf
, 32);
14606 digest
[0] = byte_swap_32 (digest
[0]);
14607 digest
[1] = byte_swap_32 (digest
[1]);
14608 digest
[2] = byte_swap_32 (digest
[2]);
14609 digest
[3] = byte_swap_32 (digest
[3]);
14610 digest
[4] = byte_swap_32 (digest
[4]);
14611 digest
[5] = byte_swap_32 (digest
[5]);
14612 digest
[6] = byte_swap_32 (digest
[6]);
14613 digest
[7] = byte_swap_32 (digest
[7]);
14615 return (PARSER_OK
);
14618 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14620 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14622 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14624 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14626 salt_t
*salt
= hash_buf
->salt
;
14632 // first is *raw* salt
14634 char *salt_pos
= input_buf
+ 3;
14636 char *hash_pos
= strchr (salt_pos
, '$');
14638 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14640 uint salt_len
= hash_pos
- salt_pos
;
14642 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14644 salt
->salt_len
= salt_len
;
14647 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14649 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14650 salt_buf_ptr
[salt_len
] = 0;
14652 // base64 decode hash
14656 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14658 uint hash_len
= input_len
- 3 - salt_len
- 1;
14660 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14662 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14664 memcpy (digest
, tmp_buf
, 32);
14667 salt
->scrypt_N
= 16384;
14668 salt
->scrypt_r
= 1;
14669 salt
->scrypt_p
= 1;
14670 salt
->salt_iter
= 1;
14672 return (PARSER_OK
);
14675 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14677 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14679 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14681 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14683 salt_t
*salt
= hash_buf
->salt
;
14685 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14691 char *version_pos
= input_buf
+ 8 + 1;
14693 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14695 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14697 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14699 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14701 verifierHashSize_pos
++;
14703 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14705 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14707 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14709 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14713 char *saltSize_pos
= strchr (keySize_pos
, '*');
14715 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14717 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14719 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14723 char *osalt_pos
= strchr (saltSize_pos
, '*');
14725 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14727 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14729 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14733 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14735 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14737 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14739 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14741 encryptedVerifier_pos
++;
14743 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14745 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14747 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14749 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14751 encryptedVerifierHash_pos
++;
14753 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;
14755 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14757 const uint version
= atoi (version_pos
);
14759 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14761 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14763 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14765 const uint keySize
= atoi (keySize_pos
);
14767 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14769 office2007
->keySize
= keySize
;
14771 const uint saltSize
= atoi (saltSize_pos
);
14773 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14779 salt
->salt_len
= 16;
14780 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14782 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14783 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14784 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14785 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14791 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14792 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14793 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14794 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14796 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14797 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14798 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14799 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14800 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14806 digest
[0] = office2007
->encryptedVerifierHash
[0];
14807 digest
[1] = office2007
->encryptedVerifierHash
[1];
14808 digest
[2] = office2007
->encryptedVerifierHash
[2];
14809 digest
[3] = office2007
->encryptedVerifierHash
[3];
14811 return (PARSER_OK
);
14814 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14816 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14818 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14820 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14822 salt_t
*salt
= hash_buf
->salt
;
14824 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14830 char *version_pos
= input_buf
+ 8 + 1;
14832 char *spinCount_pos
= strchr (version_pos
, '*');
14834 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14836 uint32_t version_len
= spinCount_pos
- version_pos
;
14838 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14842 char *keySize_pos
= strchr (spinCount_pos
, '*');
14844 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14846 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14848 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14852 char *saltSize_pos
= strchr (keySize_pos
, '*');
14854 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14856 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14858 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14862 char *osalt_pos
= strchr (saltSize_pos
, '*');
14864 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14866 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14868 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14872 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14874 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14876 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14878 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14880 encryptedVerifier_pos
++;
14882 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14884 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14886 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14888 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14890 encryptedVerifierHash_pos
++;
14892 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;
14894 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14896 const uint version
= atoi (version_pos
);
14898 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14900 const uint spinCount
= atoi (spinCount_pos
);
14902 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14904 const uint keySize
= atoi (keySize_pos
);
14906 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14908 const uint saltSize
= atoi (saltSize_pos
);
14910 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14916 salt
->salt_len
= 16;
14917 salt
->salt_iter
= spinCount
;
14919 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14920 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14921 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14922 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14928 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14929 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14930 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14931 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14933 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14934 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14935 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14936 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14937 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14938 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14939 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14940 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14946 digest
[0] = office2010
->encryptedVerifierHash
[0];
14947 digest
[1] = office2010
->encryptedVerifierHash
[1];
14948 digest
[2] = office2010
->encryptedVerifierHash
[2];
14949 digest
[3] = office2010
->encryptedVerifierHash
[3];
14951 return (PARSER_OK
);
14954 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14956 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14958 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14960 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14962 salt_t
*salt
= hash_buf
->salt
;
14964 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14970 char *version_pos
= input_buf
+ 8 + 1;
14972 char *spinCount_pos
= strchr (version_pos
, '*');
14974 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14976 uint32_t version_len
= spinCount_pos
- version_pos
;
14978 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14982 char *keySize_pos
= strchr (spinCount_pos
, '*');
14984 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14986 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14988 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14992 char *saltSize_pos
= strchr (keySize_pos
, '*');
14994 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14996 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14998 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15002 char *osalt_pos
= strchr (saltSize_pos
, '*');
15004 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15006 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
15008 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15012 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15014 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15016 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15018 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15020 encryptedVerifier_pos
++;
15022 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15024 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15026 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15028 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15030 encryptedVerifierHash_pos
++;
15032 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;
15034 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15036 const uint version
= atoi (version_pos
);
15038 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15040 const uint spinCount
= atoi (spinCount_pos
);
15042 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15044 const uint keySize
= atoi (keySize_pos
);
15046 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15048 const uint saltSize
= atoi (saltSize_pos
);
15050 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15056 salt
->salt_len
= 16;
15057 salt
->salt_iter
= spinCount
;
15059 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15060 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15061 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15062 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15068 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15069 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15070 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15071 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15073 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15074 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15075 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15076 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15077 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15078 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15079 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15080 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15086 digest
[0] = office2013
->encryptedVerifierHash
[0];
15087 digest
[1] = office2013
->encryptedVerifierHash
[1];
15088 digest
[2] = office2013
->encryptedVerifierHash
[2];
15089 digest
[3] = office2013
->encryptedVerifierHash
[3];
15091 return (PARSER_OK
);
15094 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15096 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15098 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15100 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15102 salt_t
*salt
= hash_buf
->salt
;
15104 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15110 char *version_pos
= input_buf
+ 11;
15112 char *osalt_pos
= strchr (version_pos
, '*');
15114 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15116 uint32_t version_len
= osalt_pos
- version_pos
;
15118 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15122 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15124 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15126 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15128 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15130 encryptedVerifier_pos
++;
15132 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15134 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15136 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15138 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15140 encryptedVerifierHash_pos
++;
15142 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15144 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15146 const uint version
= *version_pos
- 0x30;
15148 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15154 oldoffice01
->version
= version
;
15156 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15157 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15158 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15159 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15161 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15162 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15163 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15164 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15166 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15167 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15168 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15169 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15171 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15172 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15173 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15174 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15180 salt
->salt_len
= 16;
15182 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15183 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15184 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15185 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15187 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15188 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15189 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15190 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15192 // this is a workaround as office produces multiple documents with the same salt
15194 salt
->salt_len
+= 32;
15196 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15197 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15198 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15199 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15200 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15201 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15202 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15203 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15209 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15210 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15211 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15212 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15214 return (PARSER_OK
);
15217 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15219 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15222 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15224 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15226 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15228 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15230 salt_t
*salt
= hash_buf
->salt
;
15232 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15238 char *version_pos
= input_buf
+ 11;
15240 char *osalt_pos
= strchr (version_pos
, '*');
15242 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15244 uint32_t version_len
= osalt_pos
- version_pos
;
15246 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15250 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15252 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15254 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15256 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15258 encryptedVerifier_pos
++;
15260 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15262 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15264 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15266 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15268 encryptedVerifierHash_pos
++;
15270 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15272 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15274 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15276 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15280 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15282 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15284 const uint version
= *version_pos
- 0x30;
15286 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15292 oldoffice01
->version
= version
;
15294 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15295 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15296 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15297 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15299 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15300 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15301 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15302 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15304 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15305 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15306 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15307 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15309 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15310 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15311 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15312 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15314 oldoffice01
->rc4key
[1] = 0;
15315 oldoffice01
->rc4key
[0] = 0;
15317 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15318 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15319 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15320 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15321 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15322 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15323 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15324 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15325 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15326 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15328 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15329 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15335 salt
->salt_len
= 16;
15337 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15338 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15339 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15340 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15342 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15343 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15344 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15345 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15347 // this is a workaround as office produces multiple documents with the same salt
15349 salt
->salt_len
+= 32;
15351 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15352 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15353 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15354 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15355 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15356 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15357 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15358 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15364 digest
[0] = oldoffice01
->rc4key
[0];
15365 digest
[1] = oldoffice01
->rc4key
[1];
15369 return (PARSER_OK
);
15372 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15374 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15376 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15378 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15380 salt_t
*salt
= hash_buf
->salt
;
15382 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15388 char *version_pos
= input_buf
+ 11;
15390 char *osalt_pos
= strchr (version_pos
, '*');
15392 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15394 uint32_t version_len
= osalt_pos
- version_pos
;
15396 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15400 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15402 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15404 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15406 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15408 encryptedVerifier_pos
++;
15410 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15412 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15414 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15416 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15418 encryptedVerifierHash_pos
++;
15420 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15422 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15424 const uint version
= *version_pos
- 0x30;
15426 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15432 oldoffice34
->version
= version
;
15434 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15435 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15436 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15437 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15439 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15440 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15441 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15442 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15444 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15445 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15446 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15447 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15448 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15450 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15451 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15452 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15453 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15454 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15460 salt
->salt_len
= 16;
15462 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15463 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15464 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15465 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15467 // this is a workaround as office produces multiple documents with the same salt
15469 salt
->salt_len
+= 32;
15471 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15472 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15473 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15474 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15475 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15476 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15477 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15478 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15484 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15485 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15486 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15487 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15489 return (PARSER_OK
);
15492 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15494 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15496 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15499 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15501 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15503 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15505 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15507 salt_t
*salt
= hash_buf
->salt
;
15509 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15515 char *version_pos
= input_buf
+ 11;
15517 char *osalt_pos
= strchr (version_pos
, '*');
15519 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15521 uint32_t version_len
= osalt_pos
- version_pos
;
15523 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15527 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15529 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15531 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15533 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15535 encryptedVerifier_pos
++;
15537 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15539 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15541 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15543 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15545 encryptedVerifierHash_pos
++;
15547 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15549 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15551 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15553 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15557 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15559 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15561 const uint version
= *version_pos
- 0x30;
15563 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15569 oldoffice34
->version
= version
;
15571 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15572 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15573 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15574 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15576 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15577 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15578 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15579 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15581 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15582 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15583 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15584 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15585 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15587 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15588 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15589 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15590 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15591 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15593 oldoffice34
->rc4key
[1] = 0;
15594 oldoffice34
->rc4key
[0] = 0;
15596 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15597 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15598 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15599 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15600 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15601 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15602 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15603 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15604 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15605 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15607 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15608 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15614 salt
->salt_len
= 16;
15616 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15617 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15618 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15619 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15621 // this is a workaround as office produces multiple documents with the same salt
15623 salt
->salt_len
+= 32;
15625 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15626 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15627 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15628 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15629 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15630 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15631 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15632 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15638 digest
[0] = oldoffice34
->rc4key
[0];
15639 digest
[1] = oldoffice34
->rc4key
[1];
15643 return (PARSER_OK
);
15646 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15648 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15650 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15652 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15653 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15654 digest
[2] = hex_to_uint (&input_buf
[16]);
15655 digest
[3] = hex_to_uint (&input_buf
[24]);
15657 digest
[0] = byte_swap_32 (digest
[0]);
15658 digest
[1] = byte_swap_32 (digest
[1]);
15659 digest
[2] = byte_swap_32 (digest
[2]);
15660 digest
[3] = byte_swap_32 (digest
[3]);
15662 return (PARSER_OK
);
15665 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15667 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15669 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15671 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15673 salt_t
*salt
= hash_buf
->salt
;
15675 char *signature_pos
= input_buf
;
15677 char *salt_pos
= strchr (signature_pos
, '$');
15679 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15681 uint32_t signature_len
= salt_pos
- signature_pos
;
15683 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15687 char *hash_pos
= strchr (salt_pos
, '$');
15689 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15691 uint32_t salt_len
= hash_pos
- salt_pos
;
15693 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15697 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15699 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15701 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15702 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15703 digest
[2] = hex_to_uint (&hash_pos
[16]);
15704 digest
[3] = hex_to_uint (&hash_pos
[24]);
15705 digest
[4] = hex_to_uint (&hash_pos
[32]);
15707 digest
[0] -= SHA1M_A
;
15708 digest
[1] -= SHA1M_B
;
15709 digest
[2] -= SHA1M_C
;
15710 digest
[3] -= SHA1M_D
;
15711 digest
[4] -= SHA1M_E
;
15713 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15715 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15717 salt
->salt_len
= salt_len
;
15719 return (PARSER_OK
);
15722 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15724 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15726 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15728 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15730 salt_t
*salt
= hash_buf
->salt
;
15732 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15738 char *iter_pos
= input_buf
+ 14;
15740 const int iter
= atoi (iter_pos
);
15742 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15744 salt
->salt_iter
= iter
- 1;
15746 char *salt_pos
= strchr (iter_pos
, '$');
15748 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15752 char *hash_pos
= strchr (salt_pos
, '$');
15754 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15756 const uint salt_len
= hash_pos
- salt_pos
;
15760 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15762 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15764 salt
->salt_len
= salt_len
;
15766 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15767 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15769 // add some stuff to normal salt to make sorted happy
15771 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15772 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15773 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15774 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15775 salt
->salt_buf
[4] = salt
->salt_iter
;
15777 // base64 decode hash
15781 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15783 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15785 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15787 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15789 memcpy (digest
, tmp_buf
, 32);
15791 digest
[0] = byte_swap_32 (digest
[0]);
15792 digest
[1] = byte_swap_32 (digest
[1]);
15793 digest
[2] = byte_swap_32 (digest
[2]);
15794 digest
[3] = byte_swap_32 (digest
[3]);
15795 digest
[4] = byte_swap_32 (digest
[4]);
15796 digest
[5] = byte_swap_32 (digest
[5]);
15797 digest
[6] = byte_swap_32 (digest
[6]);
15798 digest
[7] = byte_swap_32 (digest
[7]);
15800 return (PARSER_OK
);
15803 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15805 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15807 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15809 salt_t
*salt
= hash_buf
->salt
;
15811 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15812 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15816 digest
[0] = byte_swap_32 (digest
[0]);
15817 digest
[1] = byte_swap_32 (digest
[1]);
15819 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15820 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15821 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15823 char iter_c
= input_buf
[17];
15824 char iter_d
= input_buf
[19];
15826 // atm only defaults, let's see if there's more request
15827 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15828 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15830 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15832 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15833 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15834 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15835 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15837 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15838 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15839 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15840 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15842 salt
->salt_len
= 16;
15844 return (PARSER_OK
);
15847 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15849 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15851 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15853 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15855 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15857 salt_t
*salt
= hash_buf
->salt
;
15859 char *salt_pos
= input_buf
+ 10;
15861 char *hash_pos
= strchr (salt_pos
, '$');
15863 uint salt_len
= hash_pos
- salt_pos
;
15865 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15869 uint hash_len
= input_len
- 10 - salt_len
- 1;
15871 // base64 decode salt
15875 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15877 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15879 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15881 tmp_buf
[salt_len
] = 0x80;
15883 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15885 salt
->salt_len
= salt_len
;
15887 // base64 decode salt
15889 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15891 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15893 uint user_len
= hash_len
- 32;
15895 char *tmp_hash
= tmp_buf
+ user_len
;
15897 user_len
--; // skip the trailing space
15899 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15900 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15901 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15902 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15904 digest
[0] = byte_swap_32 (digest
[0]);
15905 digest
[1] = byte_swap_32 (digest
[1]);
15906 digest
[2] = byte_swap_32 (digest
[2]);
15907 digest
[3] = byte_swap_32 (digest
[3]);
15909 // store username for host only (output hash if cracked)
15911 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15912 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15914 return (PARSER_OK
);
15917 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15919 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15921 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15923 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15925 salt_t
*salt
= hash_buf
->salt
;
15927 char *iter_pos
= input_buf
+ 10;
15929 uint32_t iter
= atoi (iter_pos
);
15933 return (PARSER_SALT_ITERATION
);
15936 iter
--; // first iteration is special
15938 salt
->salt_iter
= iter
;
15940 char *base64_pos
= strchr (iter_pos
, '}');
15942 if (base64_pos
== NULL
)
15944 return (PARSER_SIGNATURE_UNMATCHED
);
15949 // base64 decode salt
15951 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15955 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15957 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15959 if (decoded_len
< 24)
15961 return (PARSER_SALT_LENGTH
);
15966 uint salt_len
= decoded_len
- 20;
15968 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15969 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15971 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15973 salt
->salt_len
= salt_len
;
15977 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15979 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15980 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15981 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15982 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15983 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15985 return (PARSER_OK
);
15988 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15990 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15992 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15994 salt_t
*salt
= hash_buf
->salt
;
15996 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15997 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15998 digest
[2] = hex_to_uint (&input_buf
[16]);
15999 digest
[3] = hex_to_uint (&input_buf
[24]);
16000 digest
[4] = hex_to_uint (&input_buf
[32]);
16002 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16004 uint salt_len
= input_len
- 40 - 1;
16006 char *salt_buf
= input_buf
+ 40 + 1;
16008 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16010 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16012 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16014 salt
->salt_len
= salt_len
;
16016 return (PARSER_OK
);
16019 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16021 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16023 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16025 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16027 salt_t
*salt
= hash_buf
->salt
;
16029 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16035 char *V_pos
= input_buf
+ 5;
16037 char *R_pos
= strchr (V_pos
, '*');
16039 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16041 uint32_t V_len
= R_pos
- V_pos
;
16045 char *bits_pos
= strchr (R_pos
, '*');
16047 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16049 uint32_t R_len
= bits_pos
- R_pos
;
16053 char *P_pos
= strchr (bits_pos
, '*');
16055 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16057 uint32_t bits_len
= P_pos
- bits_pos
;
16061 char *enc_md_pos
= strchr (P_pos
, '*');
16063 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16065 uint32_t P_len
= enc_md_pos
- P_pos
;
16069 char *id_len_pos
= strchr (enc_md_pos
, '*');
16071 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16073 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16077 char *id_buf_pos
= strchr (id_len_pos
, '*');
16079 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16081 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16085 char *u_len_pos
= strchr (id_buf_pos
, '*');
16087 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16089 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16091 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16095 char *u_buf_pos
= strchr (u_len_pos
, '*');
16097 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16099 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16103 char *o_len_pos
= strchr (u_buf_pos
, '*');
16105 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16107 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16109 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16113 char *o_buf_pos
= strchr (o_len_pos
, '*');
16115 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16117 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16121 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;
16123 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16127 const int V
= atoi (V_pos
);
16128 const int R
= atoi (R_pos
);
16129 const int P
= atoi (P_pos
);
16131 if (V
!= 1) return (PARSER_SALT_VALUE
);
16132 if (R
!= 2) return (PARSER_SALT_VALUE
);
16134 const int enc_md
= atoi (enc_md_pos
);
16136 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16138 const int id_len
= atoi (id_len_pos
);
16139 const int u_len
= atoi (u_len_pos
);
16140 const int o_len
= atoi (o_len_pos
);
16142 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16143 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16144 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16146 const int bits
= atoi (bits_pos
);
16148 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16150 // copy data to esalt
16156 pdf
->enc_md
= enc_md
;
16158 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16159 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16160 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16161 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16162 pdf
->id_len
= id_len
;
16164 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16165 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16166 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16167 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16168 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16169 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16170 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16171 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16172 pdf
->u_len
= u_len
;
16174 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16175 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16176 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16177 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16178 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16179 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16180 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16181 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16182 pdf
->o_len
= o_len
;
16184 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16185 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16186 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16187 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16189 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16190 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16191 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16192 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16193 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16194 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16195 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16196 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16198 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16199 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16200 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16201 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16202 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16203 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16204 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16205 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16207 // we use ID for salt, maybe needs to change, we will see...
16209 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16210 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16211 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16212 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16213 salt
->salt_len
= pdf
->id_len
;
16215 digest
[0] = pdf
->u_buf
[0];
16216 digest
[1] = pdf
->u_buf
[1];
16217 digest
[2] = pdf
->u_buf
[2];
16218 digest
[3] = pdf
->u_buf
[3];
16220 return (PARSER_OK
);
16223 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16225 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16228 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16230 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16232 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16234 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16236 salt_t
*salt
= hash_buf
->salt
;
16238 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16244 char *V_pos
= input_buf
+ 5;
16246 char *R_pos
= strchr (V_pos
, '*');
16248 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16250 uint32_t V_len
= R_pos
- V_pos
;
16254 char *bits_pos
= strchr (R_pos
, '*');
16256 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16258 uint32_t R_len
= bits_pos
- R_pos
;
16262 char *P_pos
= strchr (bits_pos
, '*');
16264 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16266 uint32_t bits_len
= P_pos
- bits_pos
;
16270 char *enc_md_pos
= strchr (P_pos
, '*');
16272 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16274 uint32_t P_len
= enc_md_pos
- P_pos
;
16278 char *id_len_pos
= strchr (enc_md_pos
, '*');
16280 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16282 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16286 char *id_buf_pos
= strchr (id_len_pos
, '*');
16288 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16290 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16294 char *u_len_pos
= strchr (id_buf_pos
, '*');
16296 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16298 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16300 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16304 char *u_buf_pos
= strchr (u_len_pos
, '*');
16306 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16308 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16312 char *o_len_pos
= strchr (u_buf_pos
, '*');
16314 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16316 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16318 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16322 char *o_buf_pos
= strchr (o_len_pos
, '*');
16324 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16326 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16330 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16332 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16334 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16336 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16340 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;
16342 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16346 const int V
= atoi (V_pos
);
16347 const int R
= atoi (R_pos
);
16348 const int P
= atoi (P_pos
);
16350 if (V
!= 1) return (PARSER_SALT_VALUE
);
16351 if (R
!= 2) return (PARSER_SALT_VALUE
);
16353 const int enc_md
= atoi (enc_md_pos
);
16355 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16357 const int id_len
= atoi (id_len_pos
);
16358 const int u_len
= atoi (u_len_pos
);
16359 const int o_len
= atoi (o_len_pos
);
16361 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16362 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16363 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16365 const int bits
= atoi (bits_pos
);
16367 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16369 // copy data to esalt
16375 pdf
->enc_md
= enc_md
;
16377 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16378 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16379 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16380 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16381 pdf
->id_len
= id_len
;
16383 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16384 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16385 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16386 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16387 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16388 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16389 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16390 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16391 pdf
->u_len
= u_len
;
16393 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16394 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16395 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16396 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16397 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16398 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16399 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16400 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16401 pdf
->o_len
= o_len
;
16403 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16404 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16405 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16406 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16408 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16409 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16410 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16411 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16412 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16413 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16414 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16415 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16417 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16418 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16419 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16420 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16421 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16422 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16423 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16424 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16426 pdf
->rc4key
[1] = 0;
16427 pdf
->rc4key
[0] = 0;
16429 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16430 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16431 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16432 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16433 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16434 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16435 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16436 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16437 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16438 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16440 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16441 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16443 // we use ID for salt, maybe needs to change, we will see...
16445 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16446 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16447 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16448 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16449 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16450 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16451 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16452 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16453 salt
->salt_len
= pdf
->id_len
+ 16;
16455 digest
[0] = pdf
->rc4key
[0];
16456 digest
[1] = pdf
->rc4key
[1];
16460 return (PARSER_OK
);
16463 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16465 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16467 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16469 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16471 salt_t
*salt
= hash_buf
->salt
;
16473 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16479 char *V_pos
= input_buf
+ 5;
16481 char *R_pos
= strchr (V_pos
, '*');
16483 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16485 uint32_t V_len
= R_pos
- V_pos
;
16489 char *bits_pos
= strchr (R_pos
, '*');
16491 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16493 uint32_t R_len
= bits_pos
- R_pos
;
16497 char *P_pos
= strchr (bits_pos
, '*');
16499 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16501 uint32_t bits_len
= P_pos
- bits_pos
;
16505 char *enc_md_pos
= strchr (P_pos
, '*');
16507 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16509 uint32_t P_len
= enc_md_pos
- P_pos
;
16513 char *id_len_pos
= strchr (enc_md_pos
, '*');
16515 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16517 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16521 char *id_buf_pos
= strchr (id_len_pos
, '*');
16523 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16525 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16529 char *u_len_pos
= strchr (id_buf_pos
, '*');
16531 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16533 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16535 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16539 char *u_buf_pos
= strchr (u_len_pos
, '*');
16541 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16543 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16547 char *o_len_pos
= strchr (u_buf_pos
, '*');
16549 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16551 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16553 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16557 char *o_buf_pos
= strchr (o_len_pos
, '*');
16559 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16561 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16565 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;
16567 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16571 const int V
= atoi (V_pos
);
16572 const int R
= atoi (R_pos
);
16573 const int P
= atoi (P_pos
);
16577 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16578 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16580 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16582 const int id_len
= atoi (id_len_pos
);
16583 const int u_len
= atoi (u_len_pos
);
16584 const int o_len
= atoi (o_len_pos
);
16586 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16588 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16589 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16591 const int bits
= atoi (bits_pos
);
16593 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16599 enc_md
= atoi (enc_md_pos
);
16602 // copy data to esalt
16608 pdf
->enc_md
= enc_md
;
16610 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16611 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16612 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16613 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16617 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16618 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16619 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16620 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16623 pdf
->id_len
= id_len
;
16625 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16626 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16627 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16628 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16629 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16630 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16631 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16632 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16633 pdf
->u_len
= u_len
;
16635 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16636 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16637 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16638 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16639 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16640 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16641 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16642 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16643 pdf
->o_len
= o_len
;
16645 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16646 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16647 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16648 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16652 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16653 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16654 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16655 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16658 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16659 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16660 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16661 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16662 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16663 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16664 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16665 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16667 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16668 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16669 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16670 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16671 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16672 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16673 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16674 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16676 // precompute rc4 data for later use
16692 uint salt_pc_block
[32];
16694 char *salt_pc_ptr
= (char *) salt_pc_block
;
16696 memcpy (salt_pc_ptr
, padding
, 32);
16697 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16699 uint salt_pc_digest
[4];
16701 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16703 pdf
->rc4data
[0] = salt_pc_digest
[0];
16704 pdf
->rc4data
[1] = salt_pc_digest
[1];
16706 // we use ID for salt, maybe needs to change, we will see...
16708 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16709 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16710 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16711 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16712 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16713 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16714 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16715 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16716 salt
->salt_len
= pdf
->id_len
+ 16;
16718 salt
->salt_iter
= ROUNDS_PDF14
;
16720 digest
[0] = pdf
->u_buf
[0];
16721 digest
[1] = pdf
->u_buf
[1];
16725 return (PARSER_OK
);
16728 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16730 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16732 if (ret
!= PARSER_OK
)
16737 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16739 salt_t
*salt
= hash_buf
->salt
;
16741 digest
[0] -= SHA256M_A
;
16742 digest
[1] -= SHA256M_B
;
16743 digest
[2] -= SHA256M_C
;
16744 digest
[3] -= SHA256M_D
;
16745 digest
[4] -= SHA256M_E
;
16746 digest
[5] -= SHA256M_F
;
16747 digest
[6] -= SHA256M_G
;
16748 digest
[7] -= SHA256M_H
;
16750 salt
->salt_buf
[2] = 0x80;
16752 return (PARSER_OK
);
16755 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16757 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16759 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16761 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16763 salt_t
*salt
= hash_buf
->salt
;
16765 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16771 char *V_pos
= input_buf
+ 5;
16773 char *R_pos
= strchr (V_pos
, '*');
16775 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16777 uint32_t V_len
= R_pos
- V_pos
;
16781 char *bits_pos
= strchr (R_pos
, '*');
16783 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16785 uint32_t R_len
= bits_pos
- R_pos
;
16789 char *P_pos
= strchr (bits_pos
, '*');
16791 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16793 uint32_t bits_len
= P_pos
- bits_pos
;
16797 char *enc_md_pos
= strchr (P_pos
, '*');
16799 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16801 uint32_t P_len
= enc_md_pos
- P_pos
;
16805 char *id_len_pos
= strchr (enc_md_pos
, '*');
16807 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16809 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16813 char *id_buf_pos
= strchr (id_len_pos
, '*');
16815 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16817 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16821 char *u_len_pos
= strchr (id_buf_pos
, '*');
16823 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16825 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16829 char *u_buf_pos
= strchr (u_len_pos
, '*');
16831 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16833 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16837 char *o_len_pos
= strchr (u_buf_pos
, '*');
16839 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16841 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16845 char *o_buf_pos
= strchr (o_len_pos
, '*');
16847 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16849 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16853 char *last
= strchr (o_buf_pos
, '*');
16855 if (last
== NULL
) last
= input_buf
+ input_len
;
16857 uint32_t o_buf_len
= last
- o_buf_pos
;
16861 const int V
= atoi (V_pos
);
16862 const int R
= atoi (R_pos
);
16866 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16867 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16869 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16871 const int bits
= atoi (bits_pos
);
16873 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16875 int enc_md
= atoi (enc_md_pos
);
16877 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16879 const uint id_len
= atoi (id_len_pos
);
16880 const uint u_len
= atoi (u_len_pos
);
16881 const uint o_len
= atoi (o_len_pos
);
16883 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16884 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16885 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16886 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16887 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16888 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16889 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16890 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16892 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16893 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16894 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16896 // copy data to esalt
16898 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16900 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16902 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16905 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16906 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16908 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16909 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16911 salt
->salt_len
= 8;
16912 salt
->salt_iter
= ROUNDS_PDF17L8
;
16914 digest
[0] = pdf
->u_buf
[0];
16915 digest
[1] = pdf
->u_buf
[1];
16916 digest
[2] = pdf
->u_buf
[2];
16917 digest
[3] = pdf
->u_buf
[3];
16918 digest
[4] = pdf
->u_buf
[4];
16919 digest
[5] = pdf
->u_buf
[5];
16920 digest
[6] = pdf
->u_buf
[6];
16921 digest
[7] = pdf
->u_buf
[7];
16923 return (PARSER_OK
);
16926 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16928 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16930 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16932 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16934 salt_t
*salt
= hash_buf
->salt
;
16936 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16944 char *iter_pos
= input_buf
+ 7;
16946 uint32_t iter
= atoi (iter_pos
);
16948 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16949 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16951 // first is *raw* salt
16953 char *salt_pos
= strchr (iter_pos
, ':');
16955 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16959 char *hash_pos
= strchr (salt_pos
, ':');
16961 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16963 uint32_t salt_len
= hash_pos
- salt_pos
;
16965 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16969 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16971 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16975 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16977 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16979 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16981 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16982 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16984 salt
->salt_len
= salt_len
;
16985 salt
->salt_iter
= iter
- 1;
16991 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16993 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16995 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16997 memcpy (digest
, tmp_buf
, 16);
16999 digest
[0] = byte_swap_32 (digest
[0]);
17000 digest
[1] = byte_swap_32 (digest
[1]);
17001 digest
[2] = byte_swap_32 (digest
[2]);
17002 digest
[3] = byte_swap_32 (digest
[3]);
17004 // add some stuff to normal salt to make sorted happy
17006 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17007 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17008 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17009 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17010 salt
->salt_buf
[4] = salt
->salt_iter
;
17012 return (PARSER_OK
);
17015 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17017 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17019 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17021 salt_t
*salt
= hash_buf
->salt
;
17023 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17024 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17025 digest
[2] = hex_to_uint (&input_buf
[16]);
17026 digest
[3] = hex_to_uint (&input_buf
[24]);
17028 digest
[0] = byte_swap_32 (digest
[0]);
17029 digest
[1] = byte_swap_32 (digest
[1]);
17030 digest
[2] = byte_swap_32 (digest
[2]);
17031 digest
[3] = byte_swap_32 (digest
[3]);
17033 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17035 uint salt_len
= input_len
- 32 - 1;
17037 char *salt_buf
= input_buf
+ 32 + 1;
17039 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17041 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17043 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17045 salt
->salt_len
= salt_len
;
17047 return (PARSER_OK
);
17050 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17052 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17054 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17056 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17058 salt_t
*salt
= hash_buf
->salt
;
17060 char *user_pos
= input_buf
+ 10;
17062 char *salt_pos
= strchr (user_pos
, '*');
17064 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17068 char *hash_pos
= strchr (salt_pos
, '*');
17072 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17074 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17076 uint user_len
= salt_pos
- user_pos
- 1;
17078 uint salt_len
= hash_pos
- salt_pos
- 1;
17080 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17086 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17087 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17088 digest
[2] = hex_to_uint (&hash_pos
[16]);
17089 digest
[3] = hex_to_uint (&hash_pos
[24]);
17091 digest
[0] = byte_swap_32 (digest
[0]);
17092 digest
[1] = byte_swap_32 (digest
[1]);
17093 digest
[2] = byte_swap_32 (digest
[2]);
17094 digest
[3] = byte_swap_32 (digest
[3]);
17096 digest
[0] -= MD5M_A
;
17097 digest
[1] -= MD5M_B
;
17098 digest
[2] -= MD5M_C
;
17099 digest
[3] -= MD5M_D
;
17105 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17107 // first 4 bytes are the "challenge"
17109 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17110 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17111 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17112 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17114 // append the user name
17116 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17118 salt
->salt_len
= 4 + user_len
;
17120 return (PARSER_OK
);
17123 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17125 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17127 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17129 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17131 salt_t
*salt
= hash_buf
->salt
;
17133 char *salt_pos
= input_buf
+ 9;
17135 char *hash_pos
= strchr (salt_pos
, '*');
17137 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17143 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17145 uint salt_len
= hash_pos
- salt_pos
- 1;
17147 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17153 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17154 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17155 digest
[2] = hex_to_uint (&hash_pos
[16]);
17156 digest
[3] = hex_to_uint (&hash_pos
[24]);
17157 digest
[4] = hex_to_uint (&hash_pos
[32]);
17163 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17165 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17167 salt
->salt_len
= salt_len
;
17169 return (PARSER_OK
);
17172 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17174 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17176 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17178 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17180 salt_t
*salt
= hash_buf
->salt
;
17182 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17188 char *cry_master_len_pos
= input_buf
+ 9;
17190 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17192 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17194 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17196 cry_master_buf_pos
++;
17198 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17200 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17202 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17204 cry_salt_len_pos
++;
17206 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17208 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17210 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17212 cry_salt_buf_pos
++;
17214 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17216 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17218 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17222 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17224 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17226 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17230 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17232 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17234 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17238 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17240 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17242 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17244 public_key_len_pos
++;
17246 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17248 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17250 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17252 public_key_buf_pos
++;
17254 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;
17256 const uint cry_master_len
= atoi (cry_master_len_pos
);
17257 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17258 const uint ckey_len
= atoi (ckey_len_pos
);
17259 const uint public_key_len
= atoi (public_key_len_pos
);
17261 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17262 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17263 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17264 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17266 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17268 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17270 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17273 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17275 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17277 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17280 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17282 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17284 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17287 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17288 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17289 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17292 * store digest (should be unique enought, hopefully)
17295 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17296 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17297 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17298 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17304 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17306 const uint cry_rounds
= atoi (cry_rounds_pos
);
17308 salt
->salt_iter
= cry_rounds
- 1;
17310 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17312 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17314 salt
->salt_len
= salt_len
;
17316 return (PARSER_OK
);
17319 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17321 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17323 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17325 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17327 salt_t
*salt
= hash_buf
->salt
;
17329 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17331 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17333 char temp_input_buf
[input_len
+ 1];
17335 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17336 memcpy (temp_input_buf
, input_buf
, input_len
);
17340 char *URI_server_pos
= temp_input_buf
+ 6;
17342 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17344 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17346 URI_client_pos
[0] = 0;
17349 uint URI_server_len
= strlen (URI_server_pos
);
17351 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17355 char *user_pos
= strchr (URI_client_pos
, '*');
17357 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17362 uint URI_client_len
= strlen (URI_client_pos
);
17364 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17368 char *realm_pos
= strchr (user_pos
, '*');
17370 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17375 uint user_len
= strlen (user_pos
);
17377 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17381 char *method_pos
= strchr (realm_pos
, '*');
17383 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17388 uint realm_len
= strlen (realm_pos
);
17390 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17394 char *URI_prefix_pos
= strchr (method_pos
, '*');
17396 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17398 URI_prefix_pos
[0] = 0;
17401 uint method_len
= strlen (method_pos
);
17403 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17407 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17409 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17411 URI_resource_pos
[0] = 0;
17412 URI_resource_pos
++;
17414 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17416 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17420 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17422 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17424 URI_suffix_pos
[0] = 0;
17427 uint URI_resource_len
= strlen (URI_resource_pos
);
17429 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17430 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17434 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17436 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17441 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17443 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17447 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17449 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17451 nonce_client_pos
[0] = 0;
17452 nonce_client_pos
++;
17454 uint nonce_len
= strlen (nonce_pos
);
17456 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17457 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17461 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17463 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17465 nonce_count_pos
[0] = 0;
17468 uint nonce_client_len
= strlen (nonce_client_pos
);
17470 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17474 char *qop_pos
= strchr (nonce_count_pos
, '*');
17476 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17481 uint nonce_count_len
= strlen (nonce_count_pos
);
17483 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17487 char *directive_pos
= strchr (qop_pos
, '*');
17489 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17491 directive_pos
[0] = 0;
17494 uint qop_len
= strlen (qop_pos
);
17496 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17500 char *digest_pos
= strchr (directive_pos
, '*');
17502 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17507 uint directive_len
= strlen (directive_pos
);
17509 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17511 if (memcmp (directive_pos
, "MD5", 3))
17513 log_info ("ERROR: only the MD5 directive is currently supported\n");
17515 return (PARSER_SIP_AUTH_DIRECTIVE
);
17519 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17524 uint md5_max_len
= 4 * 64;
17526 uint md5_remaining_len
= md5_max_len
;
17528 uint tmp_md5_buf
[md5_max_len
/ 4];
17530 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17532 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17534 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17536 md5_len
+= method_len
+ 1;
17537 tmp_md5_ptr
+= method_len
+ 1;
17539 if (URI_prefix_len
> 0)
17541 md5_remaining_len
= md5_max_len
- md5_len
;
17543 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17545 md5_len
+= URI_prefix_len
+ 1;
17546 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17549 md5_remaining_len
= md5_max_len
- md5_len
;
17551 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17553 md5_len
+= URI_resource_len
;
17554 tmp_md5_ptr
+= URI_resource_len
;
17556 if (URI_suffix_len
> 0)
17558 md5_remaining_len
= md5_max_len
- md5_len
;
17560 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17562 md5_len
+= 1 + URI_suffix_len
;
17565 uint tmp_digest
[4];
17567 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17569 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17570 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17571 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17572 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17578 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17580 uint esalt_len
= 0;
17582 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17584 // there are 2 possibilities for the esalt:
17586 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17588 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17590 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17592 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17604 esalt_len
= 1 + nonce_len
+ 1 + 32;
17606 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17608 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17616 // add 0x80 to esalt
17618 esalt_buf_ptr
[esalt_len
] = 0x80;
17620 sip
->esalt_len
= esalt_len
;
17626 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17628 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17630 uint max_salt_len
= 119;
17632 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17634 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17636 sip
->salt_len
= salt_len
;
17639 * fake salt (for sorting)
17642 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17646 uint fake_salt_len
= salt_len
;
17648 if (fake_salt_len
> max_salt_len
)
17650 fake_salt_len
= max_salt_len
;
17653 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17655 salt
->salt_len
= fake_salt_len
;
17661 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17662 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17663 digest
[2] = hex_to_uint (&digest_pos
[16]);
17664 digest
[3] = hex_to_uint (&digest_pos
[24]);
17666 digest
[0] = byte_swap_32 (digest
[0]);
17667 digest
[1] = byte_swap_32 (digest
[1]);
17668 digest
[2] = byte_swap_32 (digest
[2]);
17669 digest
[3] = byte_swap_32 (digest
[3]);
17671 return (PARSER_OK
);
17674 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17676 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17678 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17680 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17682 salt_t
*salt
= hash_buf
->salt
;
17686 char *digest_pos
= input_buf
;
17688 digest
[0] = hex_to_uint (&digest_pos
[0]);
17695 char *salt_buf
= input_buf
+ 8 + 1;
17699 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17701 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17703 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17705 salt
->salt_len
= salt_len
;
17707 return (PARSER_OK
);
17710 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17712 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17714 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17716 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17718 salt_t
*salt
= hash_buf
->salt
;
17720 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17726 char *p_buf_pos
= input_buf
+ 4;
17728 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17730 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17732 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17734 NumCyclesPower_pos
++;
17736 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17738 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17740 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17744 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17746 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17748 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17752 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17754 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17756 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17760 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17762 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17764 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17768 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17770 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17772 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17776 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17778 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17780 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17784 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17786 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17788 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17792 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17794 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17796 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17800 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;
17802 const uint iter
= atoi (NumCyclesPower_pos
);
17803 const uint crc
= atoi (crc_buf_pos
);
17804 const uint p_buf
= atoi (p_buf_pos
);
17805 const uint salt_len
= atoi (salt_len_pos
);
17806 const uint iv_len
= atoi (iv_len_pos
);
17807 const uint unpack_size
= atoi (unpack_size_pos
);
17808 const uint data_len
= atoi (data_len_pos
);
17814 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17815 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17817 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17819 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17821 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17827 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17828 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17829 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17830 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17832 seven_zip
->iv_len
= iv_len
;
17834 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17836 seven_zip
->salt_len
= 0;
17838 seven_zip
->crc
= crc
;
17840 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17842 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17844 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17847 seven_zip
->data_len
= data_len
;
17849 seven_zip
->unpack_size
= unpack_size
;
17853 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17854 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17855 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17856 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17858 salt
->salt_len
= 16;
17860 salt
->salt_sign
[0] = iter
;
17862 salt
->salt_iter
= 1 << iter
;
17873 return (PARSER_OK
);
17876 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17878 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17880 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17882 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17883 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17884 digest
[2] = hex_to_uint (&input_buf
[16]);
17885 digest
[3] = hex_to_uint (&input_buf
[24]);
17886 digest
[4] = hex_to_uint (&input_buf
[32]);
17887 digest
[5] = hex_to_uint (&input_buf
[40]);
17888 digest
[6] = hex_to_uint (&input_buf
[48]);
17889 digest
[7] = hex_to_uint (&input_buf
[56]);
17891 digest
[0] = byte_swap_32 (digest
[0]);
17892 digest
[1] = byte_swap_32 (digest
[1]);
17893 digest
[2] = byte_swap_32 (digest
[2]);
17894 digest
[3] = byte_swap_32 (digest
[3]);
17895 digest
[4] = byte_swap_32 (digest
[4]);
17896 digest
[5] = byte_swap_32 (digest
[5]);
17897 digest
[6] = byte_swap_32 (digest
[6]);
17898 digest
[7] = byte_swap_32 (digest
[7]);
17900 return (PARSER_OK
);
17903 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17905 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17907 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17909 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17910 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17911 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17912 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17913 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17914 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17915 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17916 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17917 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17918 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17919 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17920 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17921 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17922 digest
[13] = hex_to_uint (&input_buf
[104]);
17923 digest
[14] = hex_to_uint (&input_buf
[112]);
17924 digest
[15] = hex_to_uint (&input_buf
[120]);
17926 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17927 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17928 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17929 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17930 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17931 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17932 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17933 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17934 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17935 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17936 digest
[10] = byte_swap_32 (digest
[10]);
17937 digest
[11] = byte_swap_32 (digest
[11]);
17938 digest
[12] = byte_swap_32 (digest
[12]);
17939 digest
[13] = byte_swap_32 (digest
[13]);
17940 digest
[14] = byte_swap_32 (digest
[14]);
17941 digest
[15] = byte_swap_32 (digest
[15]);
17943 return (PARSER_OK
);
17946 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17948 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17950 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17952 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17954 salt_t
*salt
= hash_buf
->salt
;
17956 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17964 char *iter_pos
= input_buf
+ 4;
17966 uint32_t iter
= atoi (iter_pos
);
17968 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17969 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17971 // first is *raw* salt
17973 char *salt_pos
= strchr (iter_pos
, ':');
17975 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17979 char *hash_pos
= strchr (salt_pos
, ':');
17981 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17983 uint32_t salt_len
= hash_pos
- salt_pos
;
17985 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17989 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17991 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17995 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17997 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18001 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18002 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18004 salt
->salt_len
= salt_len
;
18005 salt
->salt_iter
= iter
- 1;
18011 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18013 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18015 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18017 memcpy (digest
, tmp_buf
, 16);
18019 // add some stuff to normal salt to make sorted happy
18021 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18022 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18023 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18024 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18025 salt
->salt_buf
[4] = salt
->salt_iter
;
18027 return (PARSER_OK
);
18030 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18032 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18034 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18036 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18038 salt_t
*salt
= hash_buf
->salt
;
18040 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18048 char *iter_pos
= input_buf
+ 5;
18050 uint32_t iter
= atoi (iter_pos
);
18052 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18053 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18055 // first is *raw* salt
18057 char *salt_pos
= strchr (iter_pos
, ':');
18059 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18063 char *hash_pos
= strchr (salt_pos
, ':');
18065 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18067 uint32_t salt_len
= hash_pos
- salt_pos
;
18069 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18073 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18075 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18079 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18081 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18083 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18085 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18086 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18088 salt
->salt_len
= salt_len
;
18089 salt
->salt_iter
= iter
- 1;
18095 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18097 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18099 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18101 memcpy (digest
, tmp_buf
, 16);
18103 digest
[0] = byte_swap_32 (digest
[0]);
18104 digest
[1] = byte_swap_32 (digest
[1]);
18105 digest
[2] = byte_swap_32 (digest
[2]);
18106 digest
[3] = byte_swap_32 (digest
[3]);
18108 // add some stuff to normal salt to make sorted happy
18110 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18111 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18112 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18113 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18114 salt
->salt_buf
[4] = salt
->salt_iter
;
18116 return (PARSER_OK
);
18119 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18121 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18123 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18125 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18127 salt_t
*salt
= hash_buf
->salt
;
18129 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18137 char *iter_pos
= input_buf
+ 7;
18139 uint32_t iter
= atoi (iter_pos
);
18141 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18142 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18144 // first is *raw* salt
18146 char *salt_pos
= strchr (iter_pos
, ':');
18148 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18152 char *hash_pos
= strchr (salt_pos
, ':');
18154 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18156 uint32_t salt_len
= hash_pos
- salt_pos
;
18158 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18162 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18164 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18168 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18170 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18172 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18174 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18175 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18177 salt
->salt_len
= salt_len
;
18178 salt
->salt_iter
= iter
- 1;
18184 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18186 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18188 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18190 memcpy (digest
, tmp_buf
, 64);
18192 digest
[0] = byte_swap_64 (digest
[0]);
18193 digest
[1] = byte_swap_64 (digest
[1]);
18194 digest
[2] = byte_swap_64 (digest
[2]);
18195 digest
[3] = byte_swap_64 (digest
[3]);
18196 digest
[4] = byte_swap_64 (digest
[4]);
18197 digest
[5] = byte_swap_64 (digest
[5]);
18198 digest
[6] = byte_swap_64 (digest
[6]);
18199 digest
[7] = byte_swap_64 (digest
[7]);
18201 // add some stuff to normal salt to make sorted happy
18203 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18204 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18205 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18206 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18207 salt
->salt_buf
[4] = salt
->salt_iter
;
18209 return (PARSER_OK
);
18212 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18214 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18216 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18218 uint
*digest
= (uint
*) hash_buf
->digest
;
18220 salt_t
*salt
= hash_buf
->salt
;
18226 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18228 char *hash_pos
= strchr (salt_pos
, '$');
18230 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18232 uint32_t salt_len
= hash_pos
- salt_pos
;
18234 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18238 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18240 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18244 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18245 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18263 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18264 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18266 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18267 salt
->salt_len
= 8;
18269 return (PARSER_OK
);
18272 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18274 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18276 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18278 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18280 if (c19
& 3) return (PARSER_HASH_VALUE
);
18282 salt_t
*salt
= hash_buf
->salt
;
18284 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18288 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18289 | itoa64_to_int (input_buf
[2]) << 6
18290 | itoa64_to_int (input_buf
[3]) << 12
18291 | itoa64_to_int (input_buf
[4]) << 18;
18295 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18296 | itoa64_to_int (input_buf
[6]) << 6
18297 | itoa64_to_int (input_buf
[7]) << 12
18298 | itoa64_to_int (input_buf
[8]) << 18;
18300 salt
->salt_len
= 4;
18304 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18306 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18308 memcpy (digest
, tmp_buf
, 8);
18312 IP (digest
[0], digest
[1], tt
);
18314 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18315 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18319 return (PARSER_OK
);
18322 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18324 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18326 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18328 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18330 salt_t
*salt
= hash_buf
->salt
;
18336 char *type_pos
= input_buf
+ 6 + 1;
18338 char *salt_pos
= strchr (type_pos
, '*');
18340 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18342 uint32_t type_len
= salt_pos
- type_pos
;
18344 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18348 char *crypted_pos
= strchr (salt_pos
, '*');
18350 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18352 uint32_t salt_len
= crypted_pos
- salt_pos
;
18354 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18358 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18360 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18366 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18367 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18369 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18370 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18372 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18373 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18374 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18375 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18377 salt
->salt_len
= 24;
18378 salt
->salt_iter
= ROUNDS_RAR3
;
18380 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18381 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18383 digest
[0] = 0xc43d7b00;
18384 digest
[1] = 0x40070000;
18388 return (PARSER_OK
);
18391 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18393 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18395 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18397 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18399 salt_t
*salt
= hash_buf
->salt
;
18401 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18407 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18409 char *param1_pos
= strchr (param0_pos
, '$');
18411 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18413 uint32_t param0_len
= param1_pos
- param0_pos
;
18417 char *param2_pos
= strchr (param1_pos
, '$');
18419 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18421 uint32_t param1_len
= param2_pos
- param1_pos
;
18425 char *param3_pos
= strchr (param2_pos
, '$');
18427 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18429 uint32_t param2_len
= param3_pos
- param2_pos
;
18433 char *param4_pos
= strchr (param3_pos
, '$');
18435 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18437 uint32_t param3_len
= param4_pos
- param3_pos
;
18441 char *param5_pos
= strchr (param4_pos
, '$');
18443 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18445 uint32_t param4_len
= param5_pos
- param4_pos
;
18449 uint32_t param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18451 char *salt_buf
= param1_pos
;
18452 char *iv
= param3_pos
;
18453 char *pswcheck
= param5_pos
;
18455 const uint salt_len
= atoi (param0_pos
);
18456 const uint iterations
= atoi (param2_pos
);
18457 const uint pswcheck_len
= atoi (param4_pos
);
18463 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18464 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18465 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18467 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18468 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18469 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18475 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
18476 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
18477 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
18478 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
18480 rar5
->iv
[0] = hex_to_uint (&iv
[ 0]);
18481 rar5
->iv
[1] = hex_to_uint (&iv
[ 8]);
18482 rar5
->iv
[2] = hex_to_uint (&iv
[16]);
18483 rar5
->iv
[3] = hex_to_uint (&iv
[24]);
18485 salt
->salt_len
= 16;
18487 salt
->salt_sign
[0] = iterations
;
18489 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18495 digest
[0] = hex_to_uint (&pswcheck
[ 0]);
18496 digest
[1] = hex_to_uint (&pswcheck
[ 8]);
18500 return (PARSER_OK
);
18503 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18505 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18507 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18509 salt_t
*salt
= hash_buf
->salt
;
18511 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18512 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18513 digest
[2] = hex_to_uint (&input_buf
[16]);
18514 digest
[3] = hex_to_uint (&input_buf
[24]);
18515 digest
[4] = hex_to_uint (&input_buf
[32]);
18516 digest
[5] = hex_to_uint (&input_buf
[40]);
18517 digest
[6] = hex_to_uint (&input_buf
[48]);
18518 digest
[7] = hex_to_uint (&input_buf
[56]);
18520 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18522 uint salt_len
= input_len
- 64 - 1;
18524 char *salt_buf
= input_buf
+ 64 + 1;
18526 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18528 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18530 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18532 salt
->salt_len
= salt_len
;
18535 * we can precompute the first sha256 transform
18540 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18541 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18542 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18543 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18544 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18545 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18546 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18547 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18548 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18549 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18550 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18551 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18552 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18553 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18554 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18555 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18559 pc256
[0] = SHA256M_A
;
18560 pc256
[1] = SHA256M_B
;
18561 pc256
[2] = SHA256M_C
;
18562 pc256
[3] = SHA256M_D
;
18563 pc256
[4] = SHA256M_E
;
18564 pc256
[5] = SHA256M_F
;
18565 pc256
[6] = SHA256M_G
;
18566 pc256
[7] = SHA256M_H
;
18568 sha256_64 (w
, pc256
);
18570 salt
->salt_buf_pc
[0] = pc256
[0];
18571 salt
->salt_buf_pc
[1] = pc256
[1];
18572 salt
->salt_buf_pc
[2] = pc256
[2];
18573 salt
->salt_buf_pc
[3] = pc256
[3];
18574 salt
->salt_buf_pc
[4] = pc256
[4];
18575 salt
->salt_buf_pc
[5] = pc256
[5];
18576 salt
->salt_buf_pc
[6] = pc256
[6];
18577 salt
->salt_buf_pc
[7] = pc256
[7];
18579 digest
[0] -= pc256
[0];
18580 digest
[1] -= pc256
[1];
18581 digest
[2] -= pc256
[2];
18582 digest
[3] -= pc256
[3];
18583 digest
[4] -= pc256
[4];
18584 digest
[5] -= pc256
[5];
18585 digest
[6] -= pc256
[6];
18586 digest
[7] -= pc256
[7];
18588 return (PARSER_OK
);
18591 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18593 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18595 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18597 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18599 salt_t
*salt
= hash_buf
->salt
;
18605 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18607 char *data_buf_pos
= strchr (data_len_pos
, '$');
18609 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18611 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18613 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18614 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18618 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18620 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18622 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18624 uint32_t data_len
= atoi (data_len_pos
);
18626 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18632 char *salt_pos
= data_buf_pos
;
18634 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18635 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18636 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18637 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18639 // this is actually the CT, which is also the hash later (if matched)
18641 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18642 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18643 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18644 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18646 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18648 salt
->salt_iter
= 10 - 1;
18654 digest
[0] = salt
->salt_buf
[4];
18655 digest
[1] = salt
->salt_buf
[5];
18656 digest
[2] = salt
->salt_buf
[6];
18657 digest
[3] = salt
->salt_buf
[7];
18659 return (PARSER_OK
);
18662 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18664 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18666 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18668 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18670 salt_t
*salt
= hash_buf
->salt
;
18676 char *salt_pos
= input_buf
+ 11 + 1;
18678 char *iter_pos
= strchr (salt_pos
, ',');
18680 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18682 uint32_t salt_len
= iter_pos
- salt_pos
;
18684 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18688 char *hash_pos
= strchr (iter_pos
, ',');
18690 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18692 uint32_t iter_len
= hash_pos
- iter_pos
;
18694 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18698 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18700 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18706 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18707 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18708 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18709 salt
->salt_buf
[3] = 0x00018000;
18711 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18712 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18713 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18714 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18716 salt
->salt_len
= salt_len
/ 2;
18718 salt
->salt_iter
= atoi (iter_pos
) - 1;
18724 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18725 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18726 digest
[2] = hex_to_uint (&hash_pos
[16]);
18727 digest
[3] = hex_to_uint (&hash_pos
[24]);
18728 digest
[4] = hex_to_uint (&hash_pos
[32]);
18729 digest
[5] = hex_to_uint (&hash_pos
[40]);
18730 digest
[6] = hex_to_uint (&hash_pos
[48]);
18731 digest
[7] = hex_to_uint (&hash_pos
[56]);
18733 return (PARSER_OK
);
18736 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18738 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18740 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18742 salt_t
*salt
= hash_buf
->salt
;
18748 char *hash_pos
= input_buf
+ 64;
18749 char *salt1_pos
= input_buf
+ 128;
18750 char *salt2_pos
= input_buf
;
18756 salt
->salt_buf
[ 0] = hex_to_uint (&salt1_pos
[ 0]);
18757 salt
->salt_buf
[ 1] = hex_to_uint (&salt1_pos
[ 8]);
18758 salt
->salt_buf
[ 2] = hex_to_uint (&salt1_pos
[16]);
18759 salt
->salt_buf
[ 3] = hex_to_uint (&salt1_pos
[24]);
18761 salt
->salt_buf
[ 4] = hex_to_uint (&salt2_pos
[ 0]);
18762 salt
->salt_buf
[ 5] = hex_to_uint (&salt2_pos
[ 8]);
18763 salt
->salt_buf
[ 6] = hex_to_uint (&salt2_pos
[16]);
18764 salt
->salt_buf
[ 7] = hex_to_uint (&salt2_pos
[24]);
18766 salt
->salt_buf
[ 8] = hex_to_uint (&salt2_pos
[32]);
18767 salt
->salt_buf
[ 9] = hex_to_uint (&salt2_pos
[40]);
18768 salt
->salt_buf
[10] = hex_to_uint (&salt2_pos
[48]);
18769 salt
->salt_buf
[11] = hex_to_uint (&salt2_pos
[56]);
18771 salt
->salt_len
= 48;
18773 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18779 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18780 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18781 digest
[2] = hex_to_uint (&hash_pos
[16]);
18782 digest
[3] = hex_to_uint (&hash_pos
[24]);
18783 digest
[4] = hex_to_uint (&hash_pos
[32]);
18784 digest
[5] = hex_to_uint (&hash_pos
[40]);
18785 digest
[6] = hex_to_uint (&hash_pos
[48]);
18786 digest
[7] = hex_to_uint (&hash_pos
[56]);
18788 return (PARSER_OK
);
18792 * parallel running threads
18797 BOOL WINAPI
sigHandler_default (DWORD sig
)
18801 case CTRL_CLOSE_EVENT
:
18804 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18805 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18806 * function otherwise it is to late (e.g. after returning from this function)
18811 SetConsoleCtrlHandler (NULL
, TRUE
);
18818 case CTRL_LOGOFF_EVENT
:
18819 case CTRL_SHUTDOWN_EVENT
:
18823 SetConsoleCtrlHandler (NULL
, TRUE
);
18831 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18835 case CTRL_CLOSE_EVENT
:
18839 SetConsoleCtrlHandler (NULL
, TRUE
);
18846 case CTRL_LOGOFF_EVENT
:
18847 case CTRL_SHUTDOWN_EVENT
:
18851 SetConsoleCtrlHandler (NULL
, TRUE
);
18859 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18861 if (callback
== NULL
)
18863 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18867 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18873 void sigHandler_default (int sig
)
18877 signal (sig
, NULL
);
18880 void sigHandler_benchmark (int sig
)
18884 signal (sig
, NULL
);
18887 void hc_signal (void (callback
) (int))
18889 if (callback
== NULL
) callback
= SIG_DFL
;
18891 signal (SIGINT
, callback
);
18892 signal (SIGTERM
, callback
);
18893 signal (SIGABRT
, callback
);
18898 void status_display ();
18900 void *thread_keypress (void *p
)
18902 int benchmark
= *((int *) p
);
18904 uint quiet
= data
.quiet
;
18908 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18910 int ch
= tty_getchar();
18912 if (ch
== -1) break;
18914 if (ch
== 0) continue;
18920 hc_thread_mutex_lock (mux_display
);
18935 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18936 if (quiet
== 0) fflush (stdout
);
18948 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18949 if (quiet
== 0) fflush (stdout
);
18961 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18962 if (quiet
== 0) fflush (stdout
);
18974 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18975 if (quiet
== 0) fflush (stdout
);
18983 if (benchmark
== 1) break;
18985 stop_at_checkpoint ();
18989 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18990 if (quiet
== 0) fflush (stdout
);
18998 if (benchmark
== 1)
19010 hc_thread_mutex_unlock (mux_display
);
19022 bool class_num (char c
)
19024 return ((c
>= '0') && (c
<= '9'));
19027 bool class_lower (char c
)
19029 return ((c
>= 'a') && (c
<= 'z'));
19032 bool class_upper (char c
)
19034 return ((c
>= 'A') && (c
<= 'Z'));
19037 bool class_alpha (char c
)
19039 return (class_lower (c
) || class_upper (c
));
19042 char conv_ctoi (char c
)
19048 else if (class_upper (c
))
19050 return c
- 'A' + (char) 10;
19053 return (char) (-1);
19056 char conv_itoc (char c
)
19064 return c
+ 'A' - (char) 10;
19067 return (char) (-1);
19074 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19075 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19076 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19077 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19078 #define MAX_KERNEL_RULES 255
19079 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19080 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19081 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19083 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19084 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19085 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19086 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19088 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19093 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19095 switch (rule_buf
[rule_pos
])
19101 case RULE_OP_MANGLE_NOOP
:
19102 SET_NAME (rule
, rule_buf
[rule_pos
]);
19105 case RULE_OP_MANGLE_LREST
:
19106 SET_NAME (rule
, rule_buf
[rule_pos
]);
19109 case RULE_OP_MANGLE_UREST
:
19110 SET_NAME (rule
, rule_buf
[rule_pos
]);
19113 case RULE_OP_MANGLE_LREST_UFIRST
:
19114 SET_NAME (rule
, rule_buf
[rule_pos
]);
19117 case RULE_OP_MANGLE_UREST_LFIRST
:
19118 SET_NAME (rule
, rule_buf
[rule_pos
]);
19121 case RULE_OP_MANGLE_TREST
:
19122 SET_NAME (rule
, rule_buf
[rule_pos
]);
19125 case RULE_OP_MANGLE_TOGGLE_AT
:
19126 SET_NAME (rule
, rule_buf
[rule_pos
]);
19127 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19130 case RULE_OP_MANGLE_REVERSE
:
19131 SET_NAME (rule
, rule_buf
[rule_pos
]);
19134 case RULE_OP_MANGLE_DUPEWORD
:
19135 SET_NAME (rule
, rule_buf
[rule_pos
]);
19138 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19139 SET_NAME (rule
, rule_buf
[rule_pos
]);
19140 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19143 case RULE_OP_MANGLE_REFLECT
:
19144 SET_NAME (rule
, rule_buf
[rule_pos
]);
19147 case RULE_OP_MANGLE_ROTATE_LEFT
:
19148 SET_NAME (rule
, rule_buf
[rule_pos
]);
19151 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19152 SET_NAME (rule
, rule_buf
[rule_pos
]);
19155 case RULE_OP_MANGLE_APPEND
:
19156 SET_NAME (rule
, rule_buf
[rule_pos
]);
19157 SET_P0 (rule
, rule_buf
[rule_pos
]);
19160 case RULE_OP_MANGLE_PREPEND
:
19161 SET_NAME (rule
, rule_buf
[rule_pos
]);
19162 SET_P0 (rule
, rule_buf
[rule_pos
]);
19165 case RULE_OP_MANGLE_DELETE_FIRST
:
19166 SET_NAME (rule
, rule_buf
[rule_pos
]);
19169 case RULE_OP_MANGLE_DELETE_LAST
:
19170 SET_NAME (rule
, rule_buf
[rule_pos
]);
19173 case RULE_OP_MANGLE_DELETE_AT
:
19174 SET_NAME (rule
, rule_buf
[rule_pos
]);
19175 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19178 case RULE_OP_MANGLE_EXTRACT
:
19179 SET_NAME (rule
, rule_buf
[rule_pos
]);
19180 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19181 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19184 case RULE_OP_MANGLE_OMIT
:
19185 SET_NAME (rule
, rule_buf
[rule_pos
]);
19186 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19187 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19190 case RULE_OP_MANGLE_INSERT
:
19191 SET_NAME (rule
, rule_buf
[rule_pos
]);
19192 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19193 SET_P1 (rule
, rule_buf
[rule_pos
]);
19196 case RULE_OP_MANGLE_OVERSTRIKE
:
19197 SET_NAME (rule
, rule_buf
[rule_pos
]);
19198 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19199 SET_P1 (rule
, rule_buf
[rule_pos
]);
19202 case RULE_OP_MANGLE_TRUNCATE_AT
:
19203 SET_NAME (rule
, rule_buf
[rule_pos
]);
19204 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19207 case RULE_OP_MANGLE_REPLACE
:
19208 SET_NAME (rule
, rule_buf
[rule_pos
]);
19209 SET_P0 (rule
, rule_buf
[rule_pos
]);
19210 SET_P1 (rule
, rule_buf
[rule_pos
]);
19213 case RULE_OP_MANGLE_PURGECHAR
:
19217 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19221 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19222 SET_NAME (rule
, rule_buf
[rule_pos
]);
19223 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19226 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19227 SET_NAME (rule
, rule_buf
[rule_pos
]);
19228 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19231 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19232 SET_NAME (rule
, rule_buf
[rule_pos
]);
19235 case RULE_OP_MANGLE_SWITCH_FIRST
:
19236 SET_NAME (rule
, rule_buf
[rule_pos
]);
19239 case RULE_OP_MANGLE_SWITCH_LAST
:
19240 SET_NAME (rule
, rule_buf
[rule_pos
]);
19243 case RULE_OP_MANGLE_SWITCH_AT
:
19244 SET_NAME (rule
, rule_buf
[rule_pos
]);
19245 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19246 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19249 case RULE_OP_MANGLE_CHR_SHIFTL
:
19250 SET_NAME (rule
, rule_buf
[rule_pos
]);
19251 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19254 case RULE_OP_MANGLE_CHR_SHIFTR
:
19255 SET_NAME (rule
, rule_buf
[rule_pos
]);
19256 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19259 case RULE_OP_MANGLE_CHR_INCR
:
19260 SET_NAME (rule
, rule_buf
[rule_pos
]);
19261 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19264 case RULE_OP_MANGLE_CHR_DECR
:
19265 SET_NAME (rule
, rule_buf
[rule_pos
]);
19266 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19269 case RULE_OP_MANGLE_REPLACE_NP1
:
19270 SET_NAME (rule
, rule_buf
[rule_pos
]);
19271 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19274 case RULE_OP_MANGLE_REPLACE_NM1
:
19275 SET_NAME (rule
, rule_buf
[rule_pos
]);
19276 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19279 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19280 SET_NAME (rule
, rule_buf
[rule_pos
]);
19281 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19284 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19285 SET_NAME (rule
, rule_buf
[rule_pos
]);
19286 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19289 case RULE_OP_MANGLE_TITLE
:
19290 SET_NAME (rule
, rule_buf
[rule_pos
]);
19299 if (rule_pos
< rule_len
) return (-1);
19304 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19308 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19312 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19316 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19320 case RULE_OP_MANGLE_NOOP
:
19321 rule_buf
[rule_pos
] = rule_cmd
;
19324 case RULE_OP_MANGLE_LREST
:
19325 rule_buf
[rule_pos
] = rule_cmd
;
19328 case RULE_OP_MANGLE_UREST
:
19329 rule_buf
[rule_pos
] = rule_cmd
;
19332 case RULE_OP_MANGLE_LREST_UFIRST
:
19333 rule_buf
[rule_pos
] = rule_cmd
;
19336 case RULE_OP_MANGLE_UREST_LFIRST
:
19337 rule_buf
[rule_pos
] = rule_cmd
;
19340 case RULE_OP_MANGLE_TREST
:
19341 rule_buf
[rule_pos
] = rule_cmd
;
19344 case RULE_OP_MANGLE_TOGGLE_AT
:
19345 rule_buf
[rule_pos
] = rule_cmd
;
19346 GET_P0_CONV (rule
);
19349 case RULE_OP_MANGLE_REVERSE
:
19350 rule_buf
[rule_pos
] = rule_cmd
;
19353 case RULE_OP_MANGLE_DUPEWORD
:
19354 rule_buf
[rule_pos
] = rule_cmd
;
19357 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19358 rule_buf
[rule_pos
] = rule_cmd
;
19359 GET_P0_CONV (rule
);
19362 case RULE_OP_MANGLE_REFLECT
:
19363 rule_buf
[rule_pos
] = rule_cmd
;
19366 case RULE_OP_MANGLE_ROTATE_LEFT
:
19367 rule_buf
[rule_pos
] = rule_cmd
;
19370 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19371 rule_buf
[rule_pos
] = rule_cmd
;
19374 case RULE_OP_MANGLE_APPEND
:
19375 rule_buf
[rule_pos
] = rule_cmd
;
19379 case RULE_OP_MANGLE_PREPEND
:
19380 rule_buf
[rule_pos
] = rule_cmd
;
19384 case RULE_OP_MANGLE_DELETE_FIRST
:
19385 rule_buf
[rule_pos
] = rule_cmd
;
19388 case RULE_OP_MANGLE_DELETE_LAST
:
19389 rule_buf
[rule_pos
] = rule_cmd
;
19392 case RULE_OP_MANGLE_DELETE_AT
:
19393 rule_buf
[rule_pos
] = rule_cmd
;
19394 GET_P0_CONV (rule
);
19397 case RULE_OP_MANGLE_EXTRACT
:
19398 rule_buf
[rule_pos
] = rule_cmd
;
19399 GET_P0_CONV (rule
);
19400 GET_P1_CONV (rule
);
19403 case RULE_OP_MANGLE_OMIT
:
19404 rule_buf
[rule_pos
] = rule_cmd
;
19405 GET_P0_CONV (rule
);
19406 GET_P1_CONV (rule
);
19409 case RULE_OP_MANGLE_INSERT
:
19410 rule_buf
[rule_pos
] = rule_cmd
;
19411 GET_P0_CONV (rule
);
19415 case RULE_OP_MANGLE_OVERSTRIKE
:
19416 rule_buf
[rule_pos
] = rule_cmd
;
19417 GET_P0_CONV (rule
);
19421 case RULE_OP_MANGLE_TRUNCATE_AT
:
19422 rule_buf
[rule_pos
] = rule_cmd
;
19423 GET_P0_CONV (rule
);
19426 case RULE_OP_MANGLE_REPLACE
:
19427 rule_buf
[rule_pos
] = rule_cmd
;
19432 case RULE_OP_MANGLE_PURGECHAR
:
19436 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19440 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19441 rule_buf
[rule_pos
] = rule_cmd
;
19442 GET_P0_CONV (rule
);
19445 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19446 rule_buf
[rule_pos
] = rule_cmd
;
19447 GET_P0_CONV (rule
);
19450 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19451 rule_buf
[rule_pos
] = rule_cmd
;
19454 case RULE_OP_MANGLE_SWITCH_FIRST
:
19455 rule_buf
[rule_pos
] = rule_cmd
;
19458 case RULE_OP_MANGLE_SWITCH_LAST
:
19459 rule_buf
[rule_pos
] = rule_cmd
;
19462 case RULE_OP_MANGLE_SWITCH_AT
:
19463 rule_buf
[rule_pos
] = rule_cmd
;
19464 GET_P0_CONV (rule
);
19465 GET_P1_CONV (rule
);
19468 case RULE_OP_MANGLE_CHR_SHIFTL
:
19469 rule_buf
[rule_pos
] = rule_cmd
;
19470 GET_P0_CONV (rule
);
19473 case RULE_OP_MANGLE_CHR_SHIFTR
:
19474 rule_buf
[rule_pos
] = rule_cmd
;
19475 GET_P0_CONV (rule
);
19478 case RULE_OP_MANGLE_CHR_INCR
:
19479 rule_buf
[rule_pos
] = rule_cmd
;
19480 GET_P0_CONV (rule
);
19483 case RULE_OP_MANGLE_CHR_DECR
:
19484 rule_buf
[rule_pos
] = rule_cmd
;
19485 GET_P0_CONV (rule
);
19488 case RULE_OP_MANGLE_REPLACE_NP1
:
19489 rule_buf
[rule_pos
] = rule_cmd
;
19490 GET_P0_CONV (rule
);
19493 case RULE_OP_MANGLE_REPLACE_NM1
:
19494 rule_buf
[rule_pos
] = rule_cmd
;
19495 GET_P0_CONV (rule
);
19498 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19499 rule_buf
[rule_pos
] = rule_cmd
;
19500 GET_P0_CONV (rule
);
19503 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19504 rule_buf
[rule_pos
] = rule_cmd
;
19505 GET_P0_CONV (rule
);
19508 case RULE_OP_MANGLE_TITLE
:
19509 rule_buf
[rule_pos
] = rule_cmd
;
19513 return rule_pos
- 1;
19531 * CPU rules : this is from hashcat sources, cpu based rules
19534 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19535 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19537 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19538 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19539 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19541 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19542 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19543 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19545 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19549 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19554 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19558 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19563 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19567 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19572 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19577 for (l
= 0; l
< arr_len
; l
++)
19579 r
= arr_len
- 1 - l
;
19583 MANGLE_SWITCH (arr
, l
, r
);
19589 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19591 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19593 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19595 return (arr_len
* 2);
19598 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19600 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19602 int orig_len
= arr_len
;
19606 for (i
= 0; i
< times
; i
++)
19608 memcpy (&arr
[arr_len
], arr
, orig_len
);
19610 arr_len
+= orig_len
;
19616 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19618 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19620 mangle_double (arr
, arr_len
);
19622 mangle_reverse (arr
+ arr_len
, arr_len
);
19624 return (arr_len
* 2);
19627 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19632 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19634 MANGLE_SWITCH (arr
, l
, r
);
19640 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19645 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19647 MANGLE_SWITCH (arr
, l
, r
);
19653 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19655 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19659 return (arr_len
+ 1);
19662 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19664 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19668 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19670 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19675 return (arr_len
+ 1);
19678 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19680 if (upos
>= arr_len
) return (arr_len
);
19684 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19686 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19689 return (arr_len
- 1);
19692 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19694 if (upos
>= arr_len
) return (arr_len
);
19696 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19700 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19702 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19708 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19710 if (upos
>= arr_len
) return (arr_len
);
19712 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19716 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19718 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19721 return (arr_len
- ulen
);
19724 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19726 if (upos
>= arr_len
) return (arr_len
);
19728 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19732 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19734 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19739 return (arr_len
+ 1);
19742 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
)
19744 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19746 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19748 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19750 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19752 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19754 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19756 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19758 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19760 return (arr_len
+ arr2_cpy
);
19763 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19765 if (upos
>= arr_len
) return (arr_len
);
19772 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19774 if (upos
>= arr_len
) return (arr_len
);
19776 memset (arr
+ upos
, 0, arr_len
- upos
);
19781 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19785 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19787 if (arr
[arr_pos
] != oldc
) continue;
19789 arr
[arr_pos
] = newc
;
19795 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19801 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19803 if (arr
[arr_pos
] == c
) continue;
19805 arr
[ret_len
] = arr
[arr_pos
];
19813 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19815 if (ulen
> arr_len
) return (arr_len
);
19817 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19821 memcpy (cs
, arr
, ulen
);
19825 for (i
= 0; i
< ulen
; i
++)
19829 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19835 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19837 if (ulen
> arr_len
) return (arr_len
);
19839 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19841 int upos
= arr_len
- ulen
;
19845 for (i
= 0; i
< ulen
; i
++)
19847 char c
= arr
[upos
+ i
];
19849 arr_len
= mangle_append (arr
, arr_len
, c
);
19855 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19857 if ( arr_len
== 0) return (arr_len
);
19858 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19860 char c
= arr
[upos
];
19864 for (i
= 0; i
< ulen
; i
++)
19866 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19872 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19874 if ( arr_len
== 0) return (arr_len
);
19875 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19879 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19881 int new_pos
= arr_pos
* 2;
19883 arr
[new_pos
] = arr
[arr_pos
];
19885 arr
[new_pos
+ 1] = arr
[arr_pos
];
19888 return (arr_len
* 2);
19891 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19893 if (upos
>= arr_len
) return (arr_len
);
19894 if (upos2
>= arr_len
) return (arr_len
);
19896 MANGLE_SWITCH (arr
, upos
, upos2
);
19901 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19903 MANGLE_SWITCH (arr
, upos
, upos2
);
19908 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19910 if (upos
>= arr_len
) return (arr_len
);
19917 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19919 if (upos
>= arr_len
) return (arr_len
);
19926 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19928 if (upos
>= arr_len
) return (arr_len
);
19935 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19937 if (upos
>= arr_len
) return (arr_len
);
19944 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19946 int upper_next
= 1;
19950 for (pos
= 0; pos
< arr_len
; pos
++)
19952 if (arr
[pos
] == ' ')
19963 MANGLE_UPPER_AT (arr
, pos
);
19967 MANGLE_LOWER_AT (arr
, pos
);
19974 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19976 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19980 uint32_t rule_pos
= 0;
19982 for (j
= 0; j
< rp_gen_num
; j
++)
19989 switch ((char) get_random_num (0, 9))
19992 r
= get_random_num (0, sizeof (grp_op_nop
));
19993 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19997 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19998 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19999 p1
= get_random_num (0, sizeof (grp_pos
));
20000 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20004 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20005 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20006 p1
= get_random_num (1, 6);
20007 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20011 r
= get_random_num (0, sizeof (grp_op_chr
));
20012 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20013 p1
= get_random_num (0x20, 0x7e);
20014 rule_buf
[rule_pos
++] = (char) p1
;
20018 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20019 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20020 p1
= get_random_num (0x20, 0x7e);
20021 rule_buf
[rule_pos
++] = (char) p1
;
20022 p2
= get_random_num (0x20, 0x7e);
20024 p2
= get_random_num (0x20, 0x7e);
20025 rule_buf
[rule_pos
++] = (char) p2
;
20029 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20030 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20031 p1
= get_random_num (0, sizeof (grp_pos
));
20032 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20033 p2
= get_random_num (0x20, 0x7e);
20034 rule_buf
[rule_pos
++] = (char) p2
;
20038 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20039 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20040 p1
= get_random_num (0, sizeof (grp_pos
));
20041 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20042 p2
= get_random_num (0, sizeof (grp_pos
));
20044 p2
= get_random_num (0, sizeof (grp_pos
));
20045 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20049 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20050 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20051 p1
= get_random_num (0, sizeof (grp_pos
));
20052 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20053 p2
= get_random_num (1, sizeof (grp_pos
));
20055 p2
= get_random_num (1, sizeof (grp_pos
));
20056 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20060 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20061 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20062 p1
= get_random_num (0, sizeof (grp_pos
));
20063 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20064 p2
= get_random_num (1, sizeof (grp_pos
));
20065 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20066 p3
= get_random_num (0, sizeof (grp_pos
));
20067 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20075 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20077 char mem
[BLOCK_SIZE
];
20079 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20081 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20083 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20085 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20087 int out_len
= in_len
;
20088 int mem_len
= in_len
;
20090 memcpy (out
, in
, out_len
);
20094 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20096 int upos
; int upos2
;
20099 switch (rule
[rule_pos
])
20104 case RULE_OP_MANGLE_NOOP
:
20107 case RULE_OP_MANGLE_LREST
:
20108 out_len
= mangle_lrest (out
, out_len
);
20111 case RULE_OP_MANGLE_UREST
:
20112 out_len
= mangle_urest (out
, out_len
);
20115 case RULE_OP_MANGLE_LREST_UFIRST
:
20116 out_len
= mangle_lrest (out
, out_len
);
20117 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20120 case RULE_OP_MANGLE_UREST_LFIRST
:
20121 out_len
= mangle_urest (out
, out_len
);
20122 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20125 case RULE_OP_MANGLE_TREST
:
20126 out_len
= mangle_trest (out
, out_len
);
20129 case RULE_OP_MANGLE_TOGGLE_AT
:
20130 NEXT_RULEPOS (rule_pos
);
20131 NEXT_RPTOI (rule
, rule_pos
, upos
);
20132 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20135 case RULE_OP_MANGLE_REVERSE
:
20136 out_len
= mangle_reverse (out
, out_len
);
20139 case RULE_OP_MANGLE_DUPEWORD
:
20140 out_len
= mangle_double (out
, out_len
);
20143 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20144 NEXT_RULEPOS (rule_pos
);
20145 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20146 out_len
= mangle_double_times (out
, out_len
, ulen
);
20149 case RULE_OP_MANGLE_REFLECT
:
20150 out_len
= mangle_reflect (out
, out_len
);
20153 case RULE_OP_MANGLE_ROTATE_LEFT
:
20154 mangle_rotate_left (out
, out_len
);
20157 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20158 mangle_rotate_right (out
, out_len
);
20161 case RULE_OP_MANGLE_APPEND
:
20162 NEXT_RULEPOS (rule_pos
);
20163 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20166 case RULE_OP_MANGLE_PREPEND
:
20167 NEXT_RULEPOS (rule_pos
);
20168 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20171 case RULE_OP_MANGLE_DELETE_FIRST
:
20172 out_len
= mangle_delete_at (out
, out_len
, 0);
20175 case RULE_OP_MANGLE_DELETE_LAST
:
20176 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20179 case RULE_OP_MANGLE_DELETE_AT
:
20180 NEXT_RULEPOS (rule_pos
);
20181 NEXT_RPTOI (rule
, rule_pos
, upos
);
20182 out_len
= mangle_delete_at (out
, out_len
, upos
);
20185 case RULE_OP_MANGLE_EXTRACT
:
20186 NEXT_RULEPOS (rule_pos
);
20187 NEXT_RPTOI (rule
, rule_pos
, upos
);
20188 NEXT_RULEPOS (rule_pos
);
20189 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20190 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20193 case RULE_OP_MANGLE_OMIT
:
20194 NEXT_RULEPOS (rule_pos
);
20195 NEXT_RPTOI (rule
, rule_pos
, upos
);
20196 NEXT_RULEPOS (rule_pos
);
20197 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20198 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20201 case RULE_OP_MANGLE_INSERT
:
20202 NEXT_RULEPOS (rule_pos
);
20203 NEXT_RPTOI (rule
, rule_pos
, upos
);
20204 NEXT_RULEPOS (rule_pos
);
20205 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20208 case RULE_OP_MANGLE_OVERSTRIKE
:
20209 NEXT_RULEPOS (rule_pos
);
20210 NEXT_RPTOI (rule
, rule_pos
, upos
);
20211 NEXT_RULEPOS (rule_pos
);
20212 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20215 case RULE_OP_MANGLE_TRUNCATE_AT
:
20216 NEXT_RULEPOS (rule_pos
);
20217 NEXT_RPTOI (rule
, rule_pos
, upos
);
20218 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20221 case RULE_OP_MANGLE_REPLACE
:
20222 NEXT_RULEPOS (rule_pos
);
20223 NEXT_RULEPOS (rule_pos
);
20224 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20227 case RULE_OP_MANGLE_PURGECHAR
:
20228 NEXT_RULEPOS (rule_pos
);
20229 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20232 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20236 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20237 NEXT_RULEPOS (rule_pos
);
20238 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20239 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20242 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20243 NEXT_RULEPOS (rule_pos
);
20244 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20245 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20248 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20249 out_len
= mangle_dupechar (out
, out_len
);
20252 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20253 NEXT_RULEPOS (rule_pos
);
20254 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20255 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20258 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20259 NEXT_RULEPOS (rule_pos
);
20260 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20261 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20264 case RULE_OP_MANGLE_SWITCH_FIRST
:
20265 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20268 case RULE_OP_MANGLE_SWITCH_LAST
:
20269 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20272 case RULE_OP_MANGLE_SWITCH_AT
:
20273 NEXT_RULEPOS (rule_pos
);
20274 NEXT_RPTOI (rule
, rule_pos
, upos
);
20275 NEXT_RULEPOS (rule_pos
);
20276 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20277 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20280 case RULE_OP_MANGLE_CHR_SHIFTL
:
20281 NEXT_RULEPOS (rule_pos
);
20282 NEXT_RPTOI (rule
, rule_pos
, upos
);
20283 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20286 case RULE_OP_MANGLE_CHR_SHIFTR
:
20287 NEXT_RULEPOS (rule_pos
);
20288 NEXT_RPTOI (rule
, rule_pos
, upos
);
20289 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20292 case RULE_OP_MANGLE_CHR_INCR
:
20293 NEXT_RULEPOS (rule_pos
);
20294 NEXT_RPTOI (rule
, rule_pos
, upos
);
20295 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20298 case RULE_OP_MANGLE_CHR_DECR
:
20299 NEXT_RULEPOS (rule_pos
);
20300 NEXT_RPTOI (rule
, rule_pos
, upos
);
20301 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20304 case RULE_OP_MANGLE_REPLACE_NP1
:
20305 NEXT_RULEPOS (rule_pos
);
20306 NEXT_RPTOI (rule
, rule_pos
, upos
);
20307 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20310 case RULE_OP_MANGLE_REPLACE_NM1
:
20311 NEXT_RULEPOS (rule_pos
);
20312 NEXT_RPTOI (rule
, rule_pos
, upos
);
20313 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20316 case RULE_OP_MANGLE_TITLE
:
20317 out_len
= mangle_title (out
, out_len
);
20320 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20321 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20322 NEXT_RULEPOS (rule_pos
);
20323 NEXT_RPTOI (rule
, rule_pos
, upos
);
20324 NEXT_RULEPOS (rule_pos
);
20325 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20326 NEXT_RULEPOS (rule_pos
);
20327 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20328 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20331 case RULE_OP_MANGLE_APPEND_MEMORY
:
20332 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20333 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20334 memcpy (out
+ out_len
, mem
, mem_len
);
20335 out_len
+= mem_len
;
20338 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20339 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20340 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20341 memcpy (mem
+ mem_len
, out
, out_len
);
20342 out_len
+= mem_len
;
20343 memcpy (out
, mem
, out_len
);
20346 case RULE_OP_MEMORIZE_WORD
:
20347 memcpy (mem
, out
, out_len
);
20351 case RULE_OP_REJECT_LESS
:
20352 NEXT_RULEPOS (rule_pos
);
20353 NEXT_RPTOI (rule
, rule_pos
, upos
);
20354 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20357 case RULE_OP_REJECT_GREATER
:
20358 NEXT_RULEPOS (rule_pos
);
20359 NEXT_RPTOI (rule
, rule_pos
, upos
);
20360 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20363 case RULE_OP_REJECT_CONTAIN
:
20364 NEXT_RULEPOS (rule_pos
);
20365 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20368 case RULE_OP_REJECT_NOT_CONTAIN
:
20369 NEXT_RULEPOS (rule_pos
);
20370 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20373 case RULE_OP_REJECT_EQUAL_FIRST
:
20374 NEXT_RULEPOS (rule_pos
);
20375 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20378 case RULE_OP_REJECT_EQUAL_LAST
:
20379 NEXT_RULEPOS (rule_pos
);
20380 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20383 case RULE_OP_REJECT_EQUAL_AT
:
20384 NEXT_RULEPOS (rule_pos
);
20385 NEXT_RPTOI (rule
, rule_pos
, upos
);
20386 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20387 NEXT_RULEPOS (rule_pos
);
20388 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20391 case RULE_OP_REJECT_CONTAINS
:
20392 NEXT_RULEPOS (rule_pos
);
20393 NEXT_RPTOI (rule
, rule_pos
, upos
);
20394 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20395 NEXT_RULEPOS (rule_pos
);
20396 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20397 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20400 case RULE_OP_REJECT_MEMORY
:
20401 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20405 return (RULE_RC_SYNTAX_ERROR
);
20410 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);