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_nv
, 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_nv, 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
);
2692 HM_LIB
hm_init (const cl_uint vendor_id
)
2694 HM_LIB hm_dll
= NULL
;
2696 if (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 (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_amd
, int *iNumberAdapters
)
2724 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll_amd
, 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_amd
, int iNumberAdapters
)
2774 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2776 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2778 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll_amd
, 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_amd
, 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_amd, 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_amd
, 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_amd
, 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_amd
, 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_amd
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3023 // store the overdrive version in hm_device
3025 // unfortunately this doesn't work since bus id and dev id are not unique
3026 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3027 // if (opencl_device_index == -1) continue;
3029 int opencl_device_index
= i
;
3031 hm_device
[opencl_device_index
].od_version
= od_version
;
3037 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3039 for (int i
= 0; i
< num_adl_adapters
; i
++)
3041 uint32_t adapter_index
= valid_adl_device_list
[i
];
3045 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3047 // store the iAdapterIndex in hm_device
3049 // unfortunately this doesn't work since bus id and dev id are not unique
3050 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3051 // if (opencl_device_index == -1) continue;
3053 int opencl_device_index
= i
;
3055 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3058 return num_adl_adapters
;
3061 int hm_get_temperature_with_device_id (const uint device_id
)
3063 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3065 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3067 if (data
.hm_dll_amd
)
3069 if (data
.hm_device
[device_id
].od_version
== 5)
3071 ADLTemperature Temperature
;
3073 Temperature
.iSize
= sizeof (ADLTemperature
);
3075 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3077 return Temperature
.iTemperature
/ 1000;
3079 else if (data
.hm_device
[device_id
].od_version
== 6)
3081 int Temperature
= 0;
3083 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3085 return Temperature
/ 1000;
3089 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3092 int temperature
= 0;
3094 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3100 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3102 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3103 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3104 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3105 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3107 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3109 return pThermalSettings
.sensor
[0].currentTemp
;
3116 int hm_get_fanspeed_with_device_id (const uint device_id
)
3118 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3119 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3121 if (data
.hm_device
[device_id
].fan_supported
== 1)
3123 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3125 if (data
.hm_dll_amd
)
3127 if (data
.hm_device
[device_id
].od_version
== 5)
3129 ADLFanSpeedValue lpFanSpeedValue
;
3131 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3133 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3134 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3135 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3137 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3139 return lpFanSpeedValue
.iFanSpeed
;
3141 else // od_version == 6
3143 ADLOD6FanSpeedInfo faninfo
;
3145 memset (&faninfo
, 0, sizeof (faninfo
));
3147 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3149 return faninfo
.iFanSpeedPercent
;
3153 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3158 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3166 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3176 int hm_get_utilization_with_device_id (const uint device_id
)
3178 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3180 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3182 if (data
.hm_dll_amd
)
3184 ADLPMActivity PMActivity
;
3186 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3188 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3190 return PMActivity
.iActivityPercent
;
3193 else if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3196 nvmlUtilization_t utilization
;
3198 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3200 return utilization
.gpu
;
3204 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3206 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3208 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3210 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3217 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3219 if (data
.hm_device
[device_id
].fan_supported
== 1)
3221 if (data
.hm_dll_amd
)
3223 if (data
.hm_device
[device_id
].od_version
== 5)
3225 ADLFanSpeedValue lpFanSpeedValue
;
3227 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3229 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3230 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3231 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3232 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3234 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3238 else // od_version == 6
3240 ADLOD6FanSpeedValue fan_speed_value
;
3242 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3244 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3245 fan_speed_value
.iFanSpeed
= fanspeed
;
3247 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3257 // helper function for status display
3259 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3261 #define VALUE_NOT_AVAILABLE "N/A"
3265 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3269 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3277 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3279 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3281 if (css_cnt
> SP_PW_MAX
)
3283 log_error ("ERROR: mask length is too long");
3288 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3290 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3292 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3293 uint cs_len
= css
[css_pos
].cs_len
;
3295 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3297 uint c
= cs_buf
[cs_pos
] & 0xff;
3304 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3306 cs_t
*cs
= &css
[css_cnt
];
3308 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3310 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3312 memset (css_uniq
, 0, css_uniq_sz
);
3316 for (i
= 0; i
< cs
->cs_len
; i
++)
3318 const uint u
= cs
->cs_buf
[i
];
3323 for (i
= 0; i
< in_len
; i
++)
3325 uint u
= in_buf
[i
] & 0xff;
3327 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3329 if (css_uniq
[u
] == 1) continue;
3333 cs
->cs_buf
[cs
->cs_len
] = u
;
3341 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3345 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3347 uint p0
= in_buf
[in_pos
] & 0xff;
3349 if (interpret
== 1 && p0
== '?')
3353 if (in_pos
== in_len
) break;
3355 uint p1
= in_buf
[in_pos
] & 0xff;
3359 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3361 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3363 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3365 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3367 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3369 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3371 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3372 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3374 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3375 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3377 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3378 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3380 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3381 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3383 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3385 default: log_error ("Syntax error: %s", in_buf
);
3391 if (data
.hex_charset
)
3395 if (in_pos
== in_len
)
3397 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3402 uint p1
= in_buf
[in_pos
] & 0xff;
3404 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3406 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3413 chr
= hex_convert (p1
) << 0;
3414 chr
|= hex_convert (p0
) << 4;
3416 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3422 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3428 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3432 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3434 sum
*= css
[css_pos
].cs_len
;
3440 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3442 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3447 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3449 char p0
= mask_buf
[mask_pos
];
3455 if (mask_pos
== mask_len
) break;
3457 char p1
= mask_buf
[mask_pos
];
3463 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3465 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3467 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3469 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3471 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3473 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3475 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3476 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3478 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3479 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3481 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3482 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3484 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3485 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3487 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3489 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3495 if (data
.hex_charset
)
3499 // if there is no 2nd hex character, show an error:
3501 if (mask_pos
== mask_len
)
3503 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3508 char p1
= mask_buf
[mask_pos
];
3510 // if they are not valid hex character, show an error:
3512 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3514 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3521 chr
|= hex_convert (p1
) << 0;
3522 chr
|= hex_convert (p0
) << 4;
3524 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3530 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3537 log_error ("ERROR: invalid mask length (0)");
3547 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3549 for (int i
= 0; i
< css_cnt
; i
++)
3551 uint len
= css
[i
].cs_len
;
3552 uint64_t next
= val
/ len
;
3553 uint pos
= val
% len
;
3554 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3559 void mp_cut_at (char *mask
, uint max
)
3563 uint mask_len
= strlen (mask
);
3565 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3567 if (mask
[i
] == '?') i
++;
3573 void mp_setup_sys (cs_t
*mp_sys
)
3577 uint donec
[CHARSIZ
];
3579 memset (donec
, 0, sizeof (donec
));
3581 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3582 mp_sys
[0].cs_buf
[pos
++] = chr
;
3583 mp_sys
[0].cs_len
= pos
; }
3585 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3586 mp_sys
[1].cs_buf
[pos
++] = chr
;
3587 mp_sys
[1].cs_len
= pos
; }
3589 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3590 mp_sys
[2].cs_buf
[pos
++] = chr
;
3591 mp_sys
[2].cs_len
= pos
; }
3593 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3594 mp_sys
[3].cs_buf
[pos
++] = chr
;
3595 mp_sys
[3].cs_len
= pos
; }
3597 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3598 mp_sys
[4].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3601 mp_sys
[5].cs_len
= pos
; }
3604 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3606 FILE *fp
= fopen (buf
, "rb");
3608 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3610 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3616 memset (mp_file
, 0, sizeof (mp_file
));
3618 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3622 len
= in_superchop (mp_file
);
3626 log_info ("WARNING: charset file corrupted");
3628 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3632 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3637 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3639 mp_usr
[index
].cs_len
= 0;
3641 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3644 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3646 char *new_mask_buf
= (char *) mymalloc (256);
3652 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3654 if (css_pos
== len
) break;
3656 char p0
= mask_buf
[mask_pos
];
3658 new_mask_buf
[mask_pos
] = p0
;
3664 if (mask_pos
== mask_len
) break;
3666 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3670 if (data
.hex_charset
)
3674 if (mask_pos
== mask_len
)
3676 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3681 char p1
= mask_buf
[mask_pos
];
3683 // if they are not valid hex character, show an error:
3685 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3687 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3692 new_mask_buf
[mask_pos
] = p1
;
3697 if (css_pos
== len
) return (new_mask_buf
);
3699 myfree (new_mask_buf
);
3708 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3714 for (i
= start
; i
< stop
; i
++)
3716 sum
*= root_css_buf
[i
].cs_len
;
3722 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3726 cs_t
*cs
= &root_css_buf
[start
];
3730 for (i
= start
; i
< stop
; i
++)
3732 const uint64_t m
= v
% cs
->cs_len
;
3733 const uint64_t d
= v
/ cs
->cs_len
;
3737 const uint k
= cs
->cs_buf
[m
];
3739 pw_buf
[i
- start
] = (char) k
;
3741 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3745 int sp_comp_val (const void *p1
, const void *p2
)
3747 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3748 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3750 return b2
->val
- b1
->val
;
3753 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
)
3760 * Initialize hcstats
3763 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3765 uint64_t *root_stats_ptr
= root_stats_buf
;
3767 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3769 for (i
= 0; i
< SP_PW_MAX
; i
++)
3771 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3773 root_stats_ptr
+= CHARSIZ
;
3776 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3778 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3780 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 for (j
= 0; j
< CHARSIZ
; j
++)
3786 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3788 markov_stats_ptr
+= CHARSIZ
;
3798 char hcstat_tmp
[256];
3800 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3802 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3804 hcstat
= hcstat_tmp
;
3807 FILE *fd
= fopen (hcstat
, "rb");
3811 log_error ("%s: %s", hcstat
, strerror (errno
));
3816 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3818 log_error ("%s: Could not load data", hcstat
);
3823 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3825 log_error ("%s: Could not load data", hcstat
);
3833 * Markov modifier of hcstat_table on user request
3838 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3839 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3844 /* Add all stats to first position */
3846 for (i
= 1; i
< SP_PW_MAX
; i
++)
3848 uint64_t *out
= root_stats_buf_by_pos
[0];
3849 uint64_t *in
= root_stats_buf_by_pos
[i
];
3851 for (j
= 0; j
< CHARSIZ
; j
++)
3857 for (i
= 1; i
< SP_PW_MAX
; i
++)
3859 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3860 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3862 for (j
= 0; j
< CHARSIZ
; j
++)
3864 for (k
= 0; k
< CHARSIZ
; k
++)
3871 /* copy them to all pw_positions */
3873 for (i
= 1; i
< SP_PW_MAX
; i
++)
3875 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3878 for (i
= 1; i
< SP_PW_MAX
; i
++)
3880 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3888 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3890 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3892 for (i
= 0; i
< SP_PW_MAX
; i
++)
3894 root_table_buf_by_pos
[i
] = root_table_ptr
;
3896 root_table_ptr
+= CHARSIZ
;
3899 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3901 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3903 for (i
= 0; i
< SP_PW_MAX
; i
++)
3905 for (j
= 0; j
< CHARSIZ
; j
++)
3907 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3909 markov_table_ptr
+= CHARSIZ
;
3914 * Convert hcstat to tables
3917 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3919 uint key
= i
% CHARSIZ
;
3921 root_table_buf
[i
].key
= key
;
3922 root_table_buf
[i
].val
= root_stats_buf
[i
];
3925 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3927 uint key
= i
% CHARSIZ
;
3929 markov_table_buf
[i
].key
= key
;
3930 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3933 myfree (root_stats_buf
);
3934 myfree (markov_stats_buf
);
3940 for (i
= 0; i
< SP_PW_MAX
; i
++)
3942 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3945 for (i
= 0; i
< SP_PW_MAX
; i
++)
3947 for (j
= 0; j
< CHARSIZ
; j
++)
3949 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3954 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
])
3957 * Convert tables to css
3960 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3962 uint pw_pos
= i
/ CHARSIZ
;
3964 cs_t
*cs
= &root_css_buf
[pw_pos
];
3966 if (cs
->cs_len
== threshold
) continue;
3968 uint key
= root_table_buf
[i
].key
;
3970 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3972 cs
->cs_buf
[cs
->cs_len
] = key
;
3978 * Convert table to css
3981 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3983 uint c
= i
/ CHARSIZ
;
3985 cs_t
*cs
= &markov_css_buf
[c
];
3987 if (cs
->cs_len
== threshold
) continue;
3989 uint pw_pos
= c
/ CHARSIZ
;
3991 uint key
= markov_table_buf
[i
].key
;
3993 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3995 cs
->cs_buf
[cs
->cs_len
] = key
;
4001 for (uint i = 0; i < 8; i++)
4003 for (uint j = 0x20; j < 0x80; j++)
4005 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4007 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4009 for (uint k = 0; k < 10; k++)
4011 printf (" %u\n", ptr->cs_buf[k]);
4018 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4020 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4022 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4032 for (uint j
= 1; j
< CHARSIZ
; j
++)
4042 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4044 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4046 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4048 out
+= CHARSIZ
* CHARSIZ
;
4049 in
+= CHARSIZ
* CHARSIZ
;
4051 for (uint j
= 0; j
< CHARSIZ
; j
++)
4058 for (uint k
= 1; k
< CHARSIZ
; k
++)
4070 * mixed shared functions
4073 void dump_hex (const char *s
, size_t size
)
4077 for (i
= 0; i
< size
; i
++)
4079 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4085 void usage_mini_print (const char *progname
)
4087 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4090 void usage_big_print (const char *progname
)
4092 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4095 char *get_exec_path ()
4097 int exec_path_len
= 1024;
4099 char *exec_path
= (char *) mymalloc (exec_path_len
);
4105 sprintf (tmp
, "/proc/%d/exe", getpid ());
4107 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4113 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4122 char *get_install_dir (const char *progname
)
4124 char *install_dir
= mystrdup (progname
);
4125 char *last_slash
= NULL
;
4127 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4131 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4137 install_dir
[0] = '.';
4141 return (install_dir
);
4144 char *get_profile_dir (const char *homedir
)
4146 #define DOT_HASHCAT ".hashcat"
4148 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4150 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4155 char *get_session_dir (const char *profile_dir
)
4157 #define SESSIONS_FOLDER "sessions"
4159 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4161 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4166 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4170 FILE *fd
= fopen (file
, "rb");
4174 log_error ("%s: %s", file
, strerror (errno
));
4179 #define MAX_KEY_SIZE (1024 * 1024)
4181 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4183 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4187 for (int fpos
= 0; fpos
< nread
; fpos
++)
4189 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4191 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4192 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4193 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4194 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4196 if (kpos
>= 64) kpos
= 0;
4204 void set_cpu_affinity (char *cpu_affinity
)
4207 DWORD_PTR aff_mask
= 0;
4218 char *devices
= strdup (cpu_affinity
);
4220 char *next
= strtok (devices
, ",");
4224 uint cpu_id
= atoi (next
);
4241 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4247 aff_mask
|= 1 << (cpu_id
- 1);
4251 CPU_SET ((cpu_id
- 1), &cpuset
);
4254 } while ((next
= strtok (NULL
, ",")) != NULL
);
4260 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4261 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4265 pthread_t thread
= pthread_self ();
4266 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4270 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4272 char *element
, *end
;
4274 end
= (char *) base
+ nmemb
* size
;
4276 for (element
= (char *) base
; element
< end
; element
+= size
)
4277 if (!compar (element
, key
))
4283 int sort_by_salt (const void *v1
, const void *v2
)
4285 const salt_t
*s1
= (const salt_t
*) v1
;
4286 const salt_t
*s2
= (const salt_t
*) v2
;
4288 const int res1
= s1
->salt_len
- s2
->salt_len
;
4290 if (res1
!= 0) return (res1
);
4292 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4294 if (res2
!= 0) return (res2
);
4302 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4303 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4310 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4311 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4317 int sort_by_salt_buf (const void *v1
, const void *v2
)
4319 const pot_t
*p1
= (const pot_t
*) v1
;
4320 const pot_t
*p2
= (const pot_t
*) v2
;
4322 const hash_t
*h1
= &p1
->hash
;
4323 const hash_t
*h2
= &p2
->hash
;
4325 const salt_t
*s1
= h1
->salt
;
4326 const salt_t
*s2
= h2
->salt
;
4332 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4333 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4339 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4341 const hash_t
*h1
= (const hash_t
*) v1
;
4342 const hash_t
*h2
= (const hash_t
*) v2
;
4344 const salt_t
*s1
= h1
->salt
;
4345 const salt_t
*s2
= h2
->salt
;
4347 // testphase: this should work
4352 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4353 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4356 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4357 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4358 if (s1->salt_len > s2->salt_len) return ( 1);
4359 if (s1->salt_len < s2->salt_len) return (-1);
4361 uint n = s1->salt_len;
4365 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4366 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4373 int sort_by_hash_t_salt_hccap (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 salt_t
*s1
= h1
->salt
;
4379 const salt_t
*s2
= h2
->salt
;
4381 // 12 - 2 (since last 2 uints contain the digest)
4386 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4387 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4393 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4395 const hash_t
*h1
= (const hash_t
*) v1
;
4396 const hash_t
*h2
= (const hash_t
*) v2
;
4398 const void *d1
= h1
->digest
;
4399 const void *d2
= h2
->digest
;
4401 return data
.sort_by_digest (d1
, d2
);
4404 int sort_by_hash (const void *v1
, const void *v2
)
4406 const hash_t
*h1
= (const hash_t
*) v1
;
4407 const hash_t
*h2
= (const hash_t
*) v2
;
4411 const salt_t
*s1
= h1
->salt
;
4412 const salt_t
*s2
= h2
->salt
;
4414 int res
= sort_by_salt (s1
, s2
);
4416 if (res
!= 0) return (res
);
4419 const void *d1
= h1
->digest
;
4420 const void *d2
= h2
->digest
;
4422 return data
.sort_by_digest (d1
, d2
);
4425 int sort_by_pot (const void *v1
, const void *v2
)
4427 const pot_t
*p1
= (const pot_t
*) v1
;
4428 const pot_t
*p2
= (const pot_t
*) v2
;
4430 const hash_t
*h1
= &p1
->hash
;
4431 const hash_t
*h2
= &p2
->hash
;
4433 return sort_by_hash (h1
, h2
);
4436 int sort_by_mtime (const void *p1
, const void *p2
)
4438 const char **f1
= (const char **) p1
;
4439 const char **f2
= (const char **) p2
;
4441 struct stat s1
; stat (*f1
, &s1
);
4442 struct stat s2
; stat (*f2
, &s2
);
4444 return s2
.st_mtime
- s1
.st_mtime
;
4447 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4449 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4450 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4452 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4455 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4457 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4458 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4460 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4463 int sort_by_stringptr (const void *p1
, const void *p2
)
4465 const char **s1
= (const char **) p1
;
4466 const char **s2
= (const char **) p2
;
4468 return strcmp (*s1
, *s2
);
4471 int sort_by_dictstat (const void *s1
, const void *s2
)
4473 dictstat_t
*d1
= (dictstat_t
*) s1
;
4474 dictstat_t
*d2
= (dictstat_t
*) s2
;
4477 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4479 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4482 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4485 int sort_by_bitmap (const void *p1
, const void *p2
)
4487 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4488 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4490 return b1
->collisions
- b2
->collisions
;
4493 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4495 const uint32_t *d1
= (const uint32_t *) v1
;
4496 const uint32_t *d2
= (const uint32_t *) v2
;
4502 if (d1
[n
] > d2
[n
]) return ( 1);
4503 if (d1
[n
] < d2
[n
]) return (-1);
4509 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4511 const uint32_t *d1
= (const uint32_t *) v1
;
4512 const uint32_t *d2
= (const uint32_t *) v2
;
4518 if (d1
[n
] > d2
[n
]) return ( 1);
4519 if (d1
[n
] < d2
[n
]) return (-1);
4525 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4527 const uint32_t *d1
= (const uint32_t *) v1
;
4528 const uint32_t *d2
= (const uint32_t *) v2
;
4534 if (d1
[n
] > d2
[n
]) return ( 1);
4535 if (d1
[n
] < d2
[n
]) return (-1);
4541 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4543 const uint32_t *d1
= (const uint32_t *) v1
;
4544 const uint32_t *d2
= (const uint32_t *) v2
;
4550 if (d1
[n
] > d2
[n
]) return ( 1);
4551 if (d1
[n
] < d2
[n
]) return (-1);
4557 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4559 const uint32_t *d1
= (const uint32_t *) v1
;
4560 const uint32_t *d2
= (const uint32_t *) v2
;
4566 if (d1
[n
] > d2
[n
]) return ( 1);
4567 if (d1
[n
] < d2
[n
]) return (-1);
4573 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4575 const uint32_t *d1
= (const uint32_t *) v1
;
4576 const uint32_t *d2
= (const uint32_t *) v2
;
4582 if (d1
[n
] > d2
[n
]) return ( 1);
4583 if (d1
[n
] < d2
[n
]) return (-1);
4589 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4591 const uint32_t *d1
= (const uint32_t *) v1
;
4592 const uint32_t *d2
= (const uint32_t *) v2
;
4598 if (d1
[n
] > d2
[n
]) return ( 1);
4599 if (d1
[n
] < d2
[n
]) return (-1);
4605 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4607 const uint32_t *d1
= (const uint32_t *) v1
;
4608 const uint32_t *d2
= (const uint32_t *) v2
;
4614 if (d1
[n
] > d2
[n
]) return ( 1);
4615 if (d1
[n
] < d2
[n
]) return (-1);
4621 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4623 const uint64_t *d1
= (const uint64_t *) v1
;
4624 const uint64_t *d2
= (const uint64_t *) v2
;
4630 if (d1
[n
] > d2
[n
]) return ( 1);
4631 if (d1
[n
] < d2
[n
]) return (-1);
4637 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4639 const uint64_t *d1
= (const uint64_t *) v1
;
4640 const uint64_t *d2
= (const uint64_t *) v2
;
4646 if (d1
[n
] > d2
[n
]) return ( 1);
4647 if (d1
[n
] < d2
[n
]) return (-1);
4653 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4655 const uint64_t *d1
= (const uint64_t *) v1
;
4656 const uint64_t *d2
= (const uint64_t *) v2
;
4662 if (d1
[n
] > d2
[n
]) return ( 1);
4663 if (d1
[n
] < d2
[n
]) return (-1);
4669 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4671 const uint32_t *d1
= (const uint32_t *) v1
;
4672 const uint32_t *d2
= (const uint32_t *) v2
;
4674 const uint dgst_pos0
= data
.dgst_pos0
;
4675 const uint dgst_pos1
= data
.dgst_pos1
;
4676 const uint dgst_pos2
= data
.dgst_pos2
;
4677 const uint dgst_pos3
= data
.dgst_pos3
;
4679 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4680 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4681 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4682 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4683 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4684 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4685 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4686 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4691 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
)
4693 uint outfile_autohex
= data
.outfile_autohex
;
4695 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4697 FILE *debug_fp
= NULL
;
4699 if (debug_file
!= NULL
)
4701 debug_fp
= fopen (debug_file
, "ab");
4708 if (debug_fp
== NULL
)
4710 log_info ("WARNING: Could not open debug-file for writing");
4714 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4716 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4718 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4721 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4723 if (debug_mode
== 4)
4725 fputc (':', debug_fp
);
4727 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4730 fputc ('\n', debug_fp
);
4732 if (debug_file
!= NULL
) fclose (debug_fp
);
4736 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4738 int needs_hexify
= 0;
4740 if (outfile_autohex
== 1)
4742 for (uint i
= 0; i
< plain_len
; i
++)
4744 if (plain_ptr
[i
] < 0x20)
4751 if (plain_ptr
[i
] > 0x7f)
4760 if (needs_hexify
== 1)
4762 fprintf (fp
, "$HEX[");
4764 for (uint i
= 0; i
< plain_len
; i
++)
4766 fprintf (fp
, "%02x", plain_ptr
[i
]);
4773 fwrite (plain_ptr
, plain_len
, 1, fp
);
4777 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
)
4779 uint outfile_format
= data
.outfile_format
;
4781 char separator
= data
.separator
;
4783 if (outfile_format
& OUTFILE_FMT_HASH
)
4785 fprintf (out_fp
, "%s", out_buf
);
4787 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4789 fputc (separator
, out_fp
);
4792 else if (data
.username
)
4794 if (username
!= NULL
)
4796 for (uint i
= 0; i
< user_len
; i
++)
4798 fprintf (out_fp
, "%c", username
[i
]);
4801 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4803 fputc (separator
, out_fp
);
4808 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4810 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4812 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4814 fputc (separator
, out_fp
);
4818 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4820 for (uint i
= 0; i
< plain_len
; i
++)
4822 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4825 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4827 fputc (separator
, out_fp
);
4831 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4834 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4839 fprintf (out_fp
, "%lu", crackpos
);
4841 fprintf (out_fp
, "%llu", crackpos
);
4846 fputc ('\n', out_fp
);
4849 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
)
4853 pot_key
.hash
.salt
= hashes_buf
->salt
;
4854 pot_key
.hash
.digest
= hashes_buf
->digest
;
4856 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4862 input_buf
[input_len
] = 0;
4865 unsigned char *username
= NULL
;
4870 user_t
*user
= hashes_buf
->hash_info
->user
;
4874 username
= (unsigned char *) (user
->user_name
);
4876 user_len
= user
->user_len
;
4880 // do output the line
4881 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4885 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4886 #define LM_MASKED_PLAIN "[notfound]"
4888 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
)
4894 pot_left_key
.hash
.salt
= hash_left
->salt
;
4895 pot_left_key
.hash
.digest
= hash_left
->digest
;
4897 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4901 uint weak_hash_found
= 0;
4903 pot_t pot_right_key
;
4905 pot_right_key
.hash
.salt
= hash_right
->salt
;
4906 pot_right_key
.hash
.digest
= hash_right
->digest
;
4908 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4910 if (pot_right_ptr
== NULL
)
4912 // special case, if "weak hash"
4914 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4916 weak_hash_found
= 1;
4918 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4920 // in theory this is not needed, but we are paranoia:
4922 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4923 pot_right_ptr
->plain_len
= 0;
4927 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4929 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
4934 // at least one half was found:
4938 input_buf
[input_len
] = 0;
4942 unsigned char *username
= NULL
;
4947 user_t
*user
= hash_left
->hash_info
->user
;
4951 username
= (unsigned char *) (user
->user_name
);
4953 user_len
= user
->user_len
;
4957 // mask the part which was not found
4959 uint left_part_masked
= 0;
4960 uint right_part_masked
= 0;
4962 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4964 if (pot_left_ptr
== NULL
)
4966 left_part_masked
= 1;
4968 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4970 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4972 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4973 pot_left_ptr
->plain_len
= mask_plain_len
;
4976 if (pot_right_ptr
== NULL
)
4978 right_part_masked
= 1;
4980 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4982 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4984 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4985 pot_right_ptr
->plain_len
= mask_plain_len
;
4988 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4992 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4994 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4996 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4998 // do output the line
5000 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5002 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5004 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5005 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5008 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
)
5012 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5014 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5016 if (pot_ptr
== NULL
)
5020 input_buf
[input_len
] = 0;
5022 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5026 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
)
5032 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5034 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5038 pot_t pot_right_key
;
5040 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5042 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5044 uint weak_hash_found
= 0;
5046 if (pot_right_ptr
== NULL
)
5048 // special case, if "weak hash"
5050 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5052 weak_hash_found
= 1;
5054 // we just need that pot_right_ptr is not a NULL pointer
5056 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5060 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5062 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5067 // ... at least one part was not cracked
5071 input_buf
[input_len
] = 0;
5073 // only show the hash part which is still not cracked
5075 uint user_len
= input_len
- 32;
5077 char hash_output
[user_len
+ 33];
5079 memset (hash_output
, 0, sizeof (hash_output
));
5081 memcpy (hash_output
, input_buf
, input_len
);
5083 if (pot_left_ptr
!= NULL
)
5085 // only show right part (because left part was already found)
5087 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5089 hash_output
[user_len
+ 16] = 0;
5092 if (pot_right_ptr
!= NULL
)
5094 // only show left part (because right part was already found)
5096 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5098 hash_output
[user_len
+ 16] = 0;
5101 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5103 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5106 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5108 uint opencl_platforms_filter
= 0;
5110 if (opencl_platforms
)
5112 char *platforms
= strdup (opencl_platforms
);
5114 char *next
= strtok (platforms
, ",");
5118 int platform
= atoi (next
);
5120 if (platform
< 1 || platform
> 31)
5122 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5127 opencl_platforms_filter
|= 1 << (platform
- 1);
5129 } while ((next
= strtok (NULL
, ",")) != NULL
);
5135 opencl_platforms_filter
= -1;
5138 return opencl_platforms_filter
;
5141 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5143 cl_device_type device_types_filter
= 0;
5145 if (opencl_device_types
)
5147 char *device_types
= strdup (opencl_device_types
);
5149 char *next
= strtok (device_types
, ",");
5153 int device_type
= atoi (next
);
5155 if (device_type
< 1 || device_type
> 3)
5157 log_error ("ERROR: invalid device_type %u specified", device_type
);
5162 device_types_filter
|= 1 << device_type
;
5164 } while ((next
= strtok (NULL
, ",")) != NULL
);
5166 free (device_types
);
5170 device_types_filter
= CL_DEVICE_TYPE_ALL
;
5173 return device_types_filter
;
5176 uint
devices_to_devicemask (char *opencl_devices
)
5178 uint opencl_devicemask
= 0;
5182 char *devices
= strdup (opencl_devices
);
5184 char *next
= strtok (devices
, ",");
5188 uint device_id
= atoi (next
);
5190 if (device_id
< 1 || device_id
> 8)
5192 log_error ("ERROR: invalid device_id %u specified", device_id
);
5197 opencl_devicemask
|= 1 << (device_id
- 1);
5199 } while ((next
= strtok (NULL
, ",")) != NULL
);
5204 return opencl_devicemask
;
5207 uint
get_random_num (uint min
, uint max
)
5209 if (min
== max
) return (min
);
5211 return (uint
) ((rand () % (max
- min
)) + min
);
5214 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5216 uint32_t quotient
= dividend
/ divisor
;
5218 if (dividend
% divisor
) quotient
++;
5223 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5225 uint64_t quotient
= dividend
/ divisor
;
5227 if (dividend
% divisor
) quotient
++;
5232 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5234 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5235 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5237 if (tm
->tm_year
- 70)
5239 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5240 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5242 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5244 else if (tm
->tm_yday
)
5246 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5247 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5249 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5251 else if (tm
->tm_hour
)
5253 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5254 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5256 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5258 else if (tm
->tm_min
)
5260 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5261 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5263 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5267 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5269 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5273 void format_speed_display (float val
, char *buf
, size_t len
)
5284 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5295 /* generate output */
5299 snprintf (buf
, len
- 1, "%.0f ", val
);
5303 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5307 void lowercase (char *buf
, int len
)
5309 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5312 void uppercase (char *buf
, int len
)
5314 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5317 int fgetl (FILE *fp
, char *line_buf
)
5323 const int c
= fgetc (fp
);
5325 if (c
== EOF
) break;
5327 line_buf
[line_len
] = (char) c
;
5331 if (line_len
== BUFSIZ
) line_len
--;
5333 if (c
== '\n') break;
5336 if (line_len
== 0) return 0;
5338 if (line_buf
[line_len
- 1] == '\n')
5342 line_buf
[line_len
] = 0;
5345 if (line_len
== 0) return 0;
5347 if (line_buf
[line_len
- 1] == '\r')
5351 line_buf
[line_len
] = 0;
5357 int in_superchop (char *buf
)
5359 int len
= strlen (buf
);
5363 if (buf
[len
- 1] == '\n')
5370 if (buf
[len
- 1] == '\r')
5385 char **scan_directory (const char *path
)
5387 char *tmp_path
= mystrdup (path
);
5389 size_t tmp_path_len
= strlen (tmp_path
);
5391 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5393 tmp_path
[tmp_path_len
- 1] = 0;
5395 tmp_path_len
= strlen (tmp_path
);
5398 char **files
= NULL
;
5404 if ((d
= opendir (tmp_path
)) != NULL
)
5408 while ((de
= readdir (d
)) != NULL
)
5410 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5412 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5414 char *path_file
= (char *) mymalloc (path_size
+ 1);
5416 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5418 path_file
[path_size
] = 0;
5422 if ((d_test
= opendir (path_file
)) != NULL
)
5430 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5434 files
[num_files
- 1] = path_file
;
5440 else if (errno
== ENOTDIR
)
5442 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5446 files
[num_files
- 1] = mystrdup (path
);
5449 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5453 files
[num_files
- 1] = NULL
;
5460 int count_dictionaries (char **dictionary_files
)
5462 if (dictionary_files
== NULL
) return 0;
5466 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5474 char *stroptitype (const uint opti_type
)
5478 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5479 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5480 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5481 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5482 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5483 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5484 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5485 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5486 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5487 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5488 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5489 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5490 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5491 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5497 char *strparser (const uint parser_status
)
5499 switch (parser_status
)
5501 case PARSER_OK
: return ((char *) PA_000
); break;
5502 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5503 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5504 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5505 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5506 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5507 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5508 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5509 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5510 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5511 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5512 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5513 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5514 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5515 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5516 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5517 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5520 return ((char *) PA_255
);
5523 char *strhashtype (const uint hash_mode
)
5527 case 0: return ((char *) HT_00000
); break;
5528 case 10: return ((char *) HT_00010
); break;
5529 case 11: return ((char *) HT_00011
); break;
5530 case 12: return ((char *) HT_00012
); break;
5531 case 20: return ((char *) HT_00020
); break;
5532 case 21: return ((char *) HT_00021
); break;
5533 case 22: return ((char *) HT_00022
); break;
5534 case 23: return ((char *) HT_00023
); break;
5535 case 30: return ((char *) HT_00030
); break;
5536 case 40: return ((char *) HT_00040
); break;
5537 case 50: return ((char *) HT_00050
); break;
5538 case 60: return ((char *) HT_00060
); break;
5539 case 100: return ((char *) HT_00100
); break;
5540 case 101: return ((char *) HT_00101
); break;
5541 case 110: return ((char *) HT_00110
); break;
5542 case 111: return ((char *) HT_00111
); break;
5543 case 112: return ((char *) HT_00112
); break;
5544 case 120: return ((char *) HT_00120
); break;
5545 case 121: return ((char *) HT_00121
); break;
5546 case 122: return ((char *) HT_00122
); break;
5547 case 124: return ((char *) HT_00124
); break;
5548 case 130: return ((char *) HT_00130
); break;
5549 case 131: return ((char *) HT_00131
); break;
5550 case 132: return ((char *) HT_00132
); break;
5551 case 133: return ((char *) HT_00133
); break;
5552 case 140: return ((char *) HT_00140
); break;
5553 case 141: return ((char *) HT_00141
); break;
5554 case 150: return ((char *) HT_00150
); break;
5555 case 160: return ((char *) HT_00160
); break;
5556 case 190: return ((char *) HT_00190
); break;
5557 case 200: return ((char *) HT_00200
); break;
5558 case 300: return ((char *) HT_00300
); break;
5559 case 400: return ((char *) HT_00400
); break;
5560 case 500: return ((char *) HT_00500
); break;
5561 case 501: return ((char *) HT_00501
); break;
5562 case 900: return ((char *) HT_00900
); break;
5563 case 910: return ((char *) HT_00910
); break;
5564 case 1000: return ((char *) HT_01000
); break;
5565 case 1100: return ((char *) HT_01100
); break;
5566 case 1400: return ((char *) HT_01400
); break;
5567 case 1410: return ((char *) HT_01410
); break;
5568 case 1420: return ((char *) HT_01420
); break;
5569 case 1421: return ((char *) HT_01421
); break;
5570 case 1430: return ((char *) HT_01430
); break;
5571 case 1440: return ((char *) HT_01440
); break;
5572 case 1441: return ((char *) HT_01441
); break;
5573 case 1450: return ((char *) HT_01450
); break;
5574 case 1460: return ((char *) HT_01460
); break;
5575 case 1500: return ((char *) HT_01500
); break;
5576 case 1600: return ((char *) HT_01600
); break;
5577 case 1700: return ((char *) HT_01700
); break;
5578 case 1710: return ((char *) HT_01710
); break;
5579 case 1711: return ((char *) HT_01711
); break;
5580 case 1720: return ((char *) HT_01720
); break;
5581 case 1722: return ((char *) HT_01722
); break;
5582 case 1730: return ((char *) HT_01730
); break;
5583 case 1731: return ((char *) HT_01731
); break;
5584 case 1740: return ((char *) HT_01740
); break;
5585 case 1750: return ((char *) HT_01750
); break;
5586 case 1760: return ((char *) HT_01760
); break;
5587 case 1800: return ((char *) HT_01800
); break;
5588 case 2100: return ((char *) HT_02100
); break;
5589 case 2400: return ((char *) HT_02400
); break;
5590 case 2410: return ((char *) HT_02410
); break;
5591 case 2500: return ((char *) HT_02500
); break;
5592 case 2600: return ((char *) HT_02600
); break;
5593 case 2611: return ((char *) HT_02611
); break;
5594 case 2612: return ((char *) HT_02612
); break;
5595 case 2711: return ((char *) HT_02711
); break;
5596 case 2811: return ((char *) HT_02811
); break;
5597 case 3000: return ((char *) HT_03000
); break;
5598 case 3100: return ((char *) HT_03100
); break;
5599 case 3200: return ((char *) HT_03200
); break;
5600 case 3710: return ((char *) HT_03710
); break;
5601 case 3711: return ((char *) HT_03711
); break;
5602 case 3800: return ((char *) HT_03800
); break;
5603 case 4300: return ((char *) HT_04300
); break;
5604 case 4400: return ((char *) HT_04400
); break;
5605 case 4500: return ((char *) HT_04500
); break;
5606 case 4700: return ((char *) HT_04700
); break;
5607 case 4800: return ((char *) HT_04800
); break;
5608 case 4900: return ((char *) HT_04900
); break;
5609 case 5000: return ((char *) HT_05000
); break;
5610 case 5100: return ((char *) HT_05100
); break;
5611 case 5200: return ((char *) HT_05200
); break;
5612 case 5300: return ((char *) HT_05300
); break;
5613 case 5400: return ((char *) HT_05400
); break;
5614 case 5500: return ((char *) HT_05500
); break;
5615 case 5600: return ((char *) HT_05600
); break;
5616 case 5700: return ((char *) HT_05700
); break;
5617 case 5800: return ((char *) HT_05800
); break;
5618 case 6000: return ((char *) HT_06000
); break;
5619 case 6100: return ((char *) HT_06100
); break;
5620 case 6211: return ((char *) HT_06211
); break;
5621 case 6212: return ((char *) HT_06212
); break;
5622 case 6213: return ((char *) HT_06213
); break;
5623 case 6221: return ((char *) HT_06221
); break;
5624 case 6222: return ((char *) HT_06222
); break;
5625 case 6223: return ((char *) HT_06223
); break;
5626 case 6231: return ((char *) HT_06231
); break;
5627 case 6232: return ((char *) HT_06232
); break;
5628 case 6233: return ((char *) HT_06233
); break;
5629 case 6241: return ((char *) HT_06241
); break;
5630 case 6242: return ((char *) HT_06242
); break;
5631 case 6243: return ((char *) HT_06243
); break;
5632 case 6300: return ((char *) HT_06300
); break;
5633 case 6400: return ((char *) HT_06400
); break;
5634 case 6500: return ((char *) HT_06500
); break;
5635 case 6600: return ((char *) HT_06600
); break;
5636 case 6700: return ((char *) HT_06700
); break;
5637 case 6800: return ((char *) HT_06800
); break;
5638 case 6900: return ((char *) HT_06900
); break;
5639 case 7100: return ((char *) HT_07100
); break;
5640 case 7200: return ((char *) HT_07200
); break;
5641 case 7300: return ((char *) HT_07300
); break;
5642 case 7400: return ((char *) HT_07400
); break;
5643 case 7500: return ((char *) HT_07500
); break;
5644 case 7600: return ((char *) HT_07600
); break;
5645 case 7700: return ((char *) HT_07700
); break;
5646 case 7800: return ((char *) HT_07800
); break;
5647 case 7900: return ((char *) HT_07900
); break;
5648 case 8000: return ((char *) HT_08000
); break;
5649 case 8100: return ((char *) HT_08100
); break;
5650 case 8200: return ((char *) HT_08200
); break;
5651 case 8300: return ((char *) HT_08300
); break;
5652 case 8400: return ((char *) HT_08400
); break;
5653 case 8500: return ((char *) HT_08500
); break;
5654 case 8600: return ((char *) HT_08600
); break;
5655 case 8700: return ((char *) HT_08700
); break;
5656 case 8800: return ((char *) HT_08800
); break;
5657 case 8900: return ((char *) HT_08900
); break;
5658 case 9000: return ((char *) HT_09000
); break;
5659 case 9100: return ((char *) HT_09100
); break;
5660 case 9200: return ((char *) HT_09200
); break;
5661 case 9300: return ((char *) HT_09300
); break;
5662 case 9400: return ((char *) HT_09400
); break;
5663 case 9500: return ((char *) HT_09500
); break;
5664 case 9600: return ((char *) HT_09600
); break;
5665 case 9700: return ((char *) HT_09700
); break;
5666 case 9710: return ((char *) HT_09710
); break;
5667 case 9720: return ((char *) HT_09720
); break;
5668 case 9800: return ((char *) HT_09800
); break;
5669 case 9810: return ((char *) HT_09810
); break;
5670 case 9820: return ((char *) HT_09820
); break;
5671 case 9900: return ((char *) HT_09900
); break;
5672 case 10000: return ((char *) HT_10000
); break;
5673 case 10100: return ((char *) HT_10100
); break;
5674 case 10200: return ((char *) HT_10200
); break;
5675 case 10300: return ((char *) HT_10300
); break;
5676 case 10400: return ((char *) HT_10400
); break;
5677 case 10410: return ((char *) HT_10410
); break;
5678 case 10420: return ((char *) HT_10420
); break;
5679 case 10500: return ((char *) HT_10500
); break;
5680 case 10600: return ((char *) HT_10600
); break;
5681 case 10700: return ((char *) HT_10700
); break;
5682 case 10800: return ((char *) HT_10800
); break;
5683 case 10900: return ((char *) HT_10900
); break;
5684 case 11000: return ((char *) HT_11000
); break;
5685 case 11100: return ((char *) HT_11100
); break;
5686 case 11200: return ((char *) HT_11200
); break;
5687 case 11300: return ((char *) HT_11300
); break;
5688 case 11400: return ((char *) HT_11400
); break;
5689 case 11500: return ((char *) HT_11500
); break;
5690 case 11600: return ((char *) HT_11600
); break;
5691 case 11700: return ((char *) HT_11700
); break;
5692 case 11800: return ((char *) HT_11800
); break;
5693 case 11900: return ((char *) HT_11900
); break;
5694 case 12000: return ((char *) HT_12000
); break;
5695 case 12100: return ((char *) HT_12100
); break;
5696 case 12200: return ((char *) HT_12200
); break;
5697 case 12300: return ((char *) HT_12300
); break;
5698 case 12400: return ((char *) HT_12400
); break;
5699 case 12500: return ((char *) HT_12500
); break;
5700 case 12600: return ((char *) HT_12600
); break;
5701 case 12700: return ((char *) HT_12700
); break;
5702 case 12800: return ((char *) HT_12800
); break;
5703 case 12900: return ((char *) HT_12900
); break;
5704 case 13000: return ((char *) HT_13000
); break;
5707 return ((char *) "Unknown");
5710 char *strstatus (const uint devices_status
)
5712 switch (devices_status
)
5714 case STATUS_INIT
: return ((char *) ST_0000
); break;
5715 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5716 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5717 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5718 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5719 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5720 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5721 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5722 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5723 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5726 return ((char *) "Unknown");
5729 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5731 uint hash_type
= data
.hash_type
;
5732 uint hash_mode
= data
.hash_mode
;
5733 uint salt_type
= data
.salt_type
;
5734 uint opts_type
= data
.opts_type
;
5735 uint opti_type
= data
.opti_type
;
5736 uint dgst_size
= data
.dgst_size
;
5738 char *hashfile
= data
.hashfile
;
5742 uint digest_buf
[64];
5744 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5746 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5748 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5750 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5756 case HASH_TYPE_DESCRYPT
:
5757 FP (digest_buf
[1], digest_buf
[0], tt
);
5760 case HASH_TYPE_DESRACF
:
5761 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5762 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5764 FP (digest_buf
[1], digest_buf
[0], tt
);
5768 FP (digest_buf
[1], digest_buf
[0], tt
);
5771 case HASH_TYPE_NETNTLM
:
5772 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5773 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5774 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5775 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5777 FP (digest_buf
[1], digest_buf
[0], tt
);
5778 FP (digest_buf
[3], digest_buf
[2], tt
);
5781 case HASH_TYPE_BSDICRYPT
:
5782 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5783 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5785 FP (digest_buf
[1], digest_buf
[0], tt
);
5790 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5795 digest_buf
[0] += MD4M_A
;
5796 digest_buf
[1] += MD4M_B
;
5797 digest_buf
[2] += MD4M_C
;
5798 digest_buf
[3] += MD4M_D
;
5802 digest_buf
[0] += MD5M_A
;
5803 digest_buf
[1] += MD5M_B
;
5804 digest_buf
[2] += MD5M_C
;
5805 digest_buf
[3] += MD5M_D
;
5808 case HASH_TYPE_SHA1
:
5809 digest_buf
[0] += SHA1M_A
;
5810 digest_buf
[1] += SHA1M_B
;
5811 digest_buf
[2] += SHA1M_C
;
5812 digest_buf
[3] += SHA1M_D
;
5813 digest_buf
[4] += SHA1M_E
;
5816 case HASH_TYPE_SHA256
:
5817 digest_buf
[0] += SHA256M_A
;
5818 digest_buf
[1] += SHA256M_B
;
5819 digest_buf
[2] += SHA256M_C
;
5820 digest_buf
[3] += SHA256M_D
;
5821 digest_buf
[4] += SHA256M_E
;
5822 digest_buf
[5] += SHA256M_F
;
5823 digest_buf
[6] += SHA256M_G
;
5824 digest_buf
[7] += SHA256M_H
;
5827 case HASH_TYPE_SHA384
:
5828 digest_buf64
[0] += SHA384M_A
;
5829 digest_buf64
[1] += SHA384M_B
;
5830 digest_buf64
[2] += SHA384M_C
;
5831 digest_buf64
[3] += SHA384M_D
;
5832 digest_buf64
[4] += SHA384M_E
;
5833 digest_buf64
[5] += SHA384M_F
;
5834 digest_buf64
[6] += 0;
5835 digest_buf64
[7] += 0;
5838 case HASH_TYPE_SHA512
:
5839 digest_buf64
[0] += SHA512M_A
;
5840 digest_buf64
[1] += SHA512M_B
;
5841 digest_buf64
[2] += SHA512M_C
;
5842 digest_buf64
[3] += SHA512M_D
;
5843 digest_buf64
[4] += SHA512M_E
;
5844 digest_buf64
[5] += SHA512M_F
;
5845 digest_buf64
[6] += SHA512M_G
;
5846 digest_buf64
[7] += SHA512M_H
;
5851 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5853 if (dgst_size
== DGST_SIZE_4_2
)
5855 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5857 else if (dgst_size
== DGST_SIZE_4_4
)
5859 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5861 else if (dgst_size
== DGST_SIZE_4_5
)
5863 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5865 else if (dgst_size
== DGST_SIZE_4_6
)
5867 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5869 else if (dgst_size
== DGST_SIZE_4_8
)
5871 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5873 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5875 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5877 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5879 else if (hash_type
== HASH_TYPE_SHA384
)
5881 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5883 else if (hash_type
== HASH_TYPE_SHA512
)
5885 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5887 else if (hash_type
== HASH_TYPE_GOST
)
5889 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5892 else if (dgst_size
== DGST_SIZE_4_64
)
5894 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5896 else if (dgst_size
== DGST_SIZE_8_25
)
5898 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5902 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5903 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5904 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5910 memset (&salt
, 0, sizeof (salt_t
));
5912 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5914 char *ptr
= (char *) salt
.salt_buf
;
5916 uint len
= salt
.salt_len
;
5918 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5924 case HASH_TYPE_NETNTLM
:
5926 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5927 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5929 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5935 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5937 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5945 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5947 uint max
= salt
.salt_len
/ 4;
5951 for (uint i
= 0; i
< max
; i
++)
5953 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5957 if (opts_type
& OPTS_TYPE_ST_HEX
)
5961 memset (tmp
, 0, sizeof (tmp
));
5963 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5965 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5970 memcpy (ptr
, tmp
, len
);
5973 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5975 memset (ptr
+ len
, 0, memset_size
);
5977 salt
.salt_len
= len
;
5981 // some modes require special encoding
5984 uint out_buf_plain
[256];
5985 uint out_buf_salt
[256];
5989 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5990 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5992 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5994 char *ptr_plain
= (char *) out_buf_plain
;
5995 char *ptr_salt
= (char *) out_buf_salt
;
5997 if (hash_mode
== 22)
6001 memset (username
, 0, sizeof (username
));
6003 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6005 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6007 uint16_t *ptr
= (uint16_t *) digest_buf
;
6009 tmp_buf
[ 0] = sig
[0];
6010 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6011 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6012 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6013 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6014 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6015 tmp_buf
[ 6] = sig
[1];
6016 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6017 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6018 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6019 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6020 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6021 tmp_buf
[12] = sig
[2];
6022 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6023 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6024 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6025 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6026 tmp_buf
[17] = sig
[3];
6027 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6028 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6029 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6030 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6031 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6032 tmp_buf
[23] = sig
[4];
6033 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6034 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6035 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6036 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6037 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6038 tmp_buf
[29] = sig
[5];
6040 snprintf (out_buf
, len
-1, "%s:%s",
6044 else if (hash_mode
== 23)
6046 // do not show the \nskyper\n part in output
6048 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6050 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6052 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6059 else if (hash_mode
== 101)
6061 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6063 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6064 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6065 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6066 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6067 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6069 memcpy (tmp_buf
, digest_buf
, 20);
6071 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6073 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6075 else if (hash_mode
== 111)
6077 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6079 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6080 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6081 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6082 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6083 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6085 memcpy (tmp_buf
, digest_buf
, 20);
6086 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6088 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
6090 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6092 else if (hash_mode
== 122)
6094 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6095 (unsigned char *) salt
.salt_buf
,
6102 else if (hash_mode
== 124)
6104 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6105 (unsigned char *) salt
.salt_buf
,
6112 else if (hash_mode
== 131)
6114 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6115 (unsigned char *) salt
.salt_buf
,
6123 else if (hash_mode
== 132)
6125 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6126 (unsigned char *) salt
.salt_buf
,
6133 else if (hash_mode
== 133)
6135 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6137 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6138 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6139 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6140 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6141 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6143 memcpy (tmp_buf
, digest_buf
, 20);
6145 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6147 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6149 else if (hash_mode
== 141)
6151 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6153 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6155 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6157 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6159 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6160 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6161 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6162 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6163 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6165 memcpy (tmp_buf
, digest_buf
, 20);
6167 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6171 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6173 else if (hash_mode
== 400)
6175 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6177 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6178 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6179 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6180 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6182 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6184 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6186 else if (hash_mode
== 500)
6188 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6190 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6191 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6192 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6193 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6195 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6197 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6199 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6203 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6206 else if (hash_mode
== 501)
6208 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6210 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6211 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6213 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6215 else if (hash_mode
== 1421)
6217 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6219 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6235 else if (hash_mode
== 1441)
6237 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6239 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6241 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6243 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6245 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6246 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6247 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6248 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6249 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6250 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6251 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6252 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6254 memcpy (tmp_buf
, digest_buf
, 32);
6256 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6260 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6262 else if (hash_mode
== 1500)
6264 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6265 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6266 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6267 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6268 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6270 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6272 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6274 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6275 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6277 memcpy (tmp_buf
, digest_buf
, 8);
6279 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6281 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6285 else if (hash_mode
== 1600)
6287 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6289 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6290 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6291 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6292 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6294 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6296 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6298 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6302 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6305 else if (hash_mode
== 1711)
6307 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6309 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6310 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6311 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6312 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6313 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6314 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6315 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6316 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6318 memcpy (tmp_buf
, digest_buf
, 64);
6319 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6321 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6323 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6325 else if (hash_mode
== 1722)
6327 uint
*ptr
= digest_buf
;
6329 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6330 (unsigned char *) salt
.salt_buf
,
6340 else if (hash_mode
== 1731)
6342 uint
*ptr
= digest_buf
;
6344 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6345 (unsigned char *) salt
.salt_buf
,
6355 else if (hash_mode
== 1800)
6359 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6360 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6361 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6362 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6363 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6364 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6365 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6366 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6368 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6370 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6372 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6376 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6379 else if (hash_mode
== 2100)
6383 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6385 salt
.salt_iter
+ 1);
6387 uint signature_len
= strlen (out_buf
);
6389 pos
+= signature_len
;
6390 len
-= signature_len
;
6392 char *salt_ptr
= (char *) salt
.salt_buf
;
6394 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6396 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6397 byte_swap_32 (digest_buf
[0]),
6398 byte_swap_32 (digest_buf
[1]),
6399 byte_swap_32 (digest_buf
[2]),
6400 byte_swap_32 (digest_buf
[3]));
6402 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6404 memcpy (tmp_buf
, digest_buf
, 16);
6406 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6408 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6409 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6410 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6411 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6413 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6414 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6415 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6416 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6418 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6419 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6420 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6421 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6423 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6424 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6425 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6426 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6428 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6429 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6430 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6431 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6435 else if (hash_mode
== 2500)
6437 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6439 wpa_t
*wpa
= &wpas
[salt_pos
];
6443 char *pke_ptr
= (char *) pke
;
6445 for (uint i
= 0; i
< 25; i
++)
6447 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6450 unsigned char mac1
[6];
6451 unsigned char mac2
[6];
6453 memcpy (mac1
, pke_ptr
+ 23, 6);
6454 memcpy (mac2
, pke_ptr
+ 29, 6);
6456 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6457 (char *) salt
.salt_buf
,
6471 else if (hash_mode
== 4400)
6473 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6474 byte_swap_32 (digest_buf
[0]),
6475 byte_swap_32 (digest_buf
[1]),
6476 byte_swap_32 (digest_buf
[2]),
6477 byte_swap_32 (digest_buf
[3]));
6479 else if (hash_mode
== 4700)
6481 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6482 byte_swap_32 (digest_buf
[0]),
6483 byte_swap_32 (digest_buf
[1]),
6484 byte_swap_32 (digest_buf
[2]),
6485 byte_swap_32 (digest_buf
[3]),
6486 byte_swap_32 (digest_buf
[4]));
6488 else if (hash_mode
== 4800)
6490 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6492 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6497 byte_swap_32 (salt
.salt_buf
[0]),
6498 byte_swap_32 (salt
.salt_buf
[1]),
6499 byte_swap_32 (salt
.salt_buf
[2]),
6500 byte_swap_32 (salt
.salt_buf
[3]),
6503 else if (hash_mode
== 4900)
6505 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6506 byte_swap_32 (digest_buf
[0]),
6507 byte_swap_32 (digest_buf
[1]),
6508 byte_swap_32 (digest_buf
[2]),
6509 byte_swap_32 (digest_buf
[3]),
6510 byte_swap_32 (digest_buf
[4]));
6512 else if (hash_mode
== 5100)
6514 snprintf (out_buf
, len
-1, "%08x%08x",
6518 else if (hash_mode
== 5200)
6520 snprintf (out_buf
, len
-1, "%s", hashfile
);
6522 else if (hash_mode
== 5300)
6524 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6526 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6528 int buf_len
= len
-1;
6532 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6534 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6536 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6538 snprintf (out_buf
, buf_len
, ":");
6544 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6552 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6554 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6556 if ((i
== 0) || (i
== 5))
6558 snprintf (out_buf
, buf_len
, ":");
6564 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6572 for (uint i
= 0; i
< 4; i
++)
6576 snprintf (out_buf
, buf_len
, ":");
6582 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6588 else if (hash_mode
== 5400)
6590 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6592 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6594 int buf_len
= len
-1;
6598 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6600 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6602 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6604 snprintf (out_buf
, buf_len
, ":");
6610 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6618 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6620 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6622 if ((i
== 0) || (i
== 5))
6624 snprintf (out_buf
, buf_len
, ":");
6630 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6638 for (uint i
= 0; i
< 5; i
++)
6642 snprintf (out_buf
, buf_len
, ":");
6648 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6654 else if (hash_mode
== 5500)
6656 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6658 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6661 char domain_buf
[64];
6662 char srvchall_buf
[1024];
6663 char clichall_buf
[1024];
6665 memset (user_buf
, 0, sizeof (user_buf
));
6666 memset (domain_buf
, 0, sizeof (domain_buf
));
6667 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6668 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6670 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6672 char *ptr
= (char *) netntlm
->userdomain_buf
;
6674 user_buf
[i
] = ptr
[j
];
6677 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6679 char *ptr
= (char *) netntlm
->userdomain_buf
;
6681 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6684 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6686 char *ptr
= (char *) netntlm
->chall_buf
;
6688 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6691 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6693 char *ptr
= (char *) netntlm
->chall_buf
;
6695 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6698 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6706 byte_swap_32 (salt
.salt_buf_pc
[0]),
6707 byte_swap_32 (salt
.salt_buf_pc
[1]),
6710 else if (hash_mode
== 5600)
6712 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6714 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6717 char domain_buf
[64];
6718 char srvchall_buf
[1024];
6719 char clichall_buf
[1024];
6721 memset (user_buf
, 0, sizeof (user_buf
));
6722 memset (domain_buf
, 0, sizeof (domain_buf
));
6723 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6724 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6726 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6728 char *ptr
= (char *) netntlm
->userdomain_buf
;
6730 user_buf
[i
] = ptr
[j
];
6733 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6735 char *ptr
= (char *) netntlm
->userdomain_buf
;
6737 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6740 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6742 char *ptr
= (char *) netntlm
->chall_buf
;
6744 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6747 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6749 char *ptr
= (char *) netntlm
->chall_buf
;
6751 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6754 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6764 else if (hash_mode
== 5700)
6766 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6768 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6769 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6770 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6771 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6772 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6773 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6774 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6775 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6777 memcpy (tmp_buf
, digest_buf
, 32);
6779 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6783 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6785 else if (hash_mode
== 5800)
6787 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6788 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6789 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6790 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6791 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6793 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6800 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6802 snprintf (out_buf
, len
-1, "%s", hashfile
);
6804 else if (hash_mode
== 6300)
6806 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6808 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6809 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6810 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6811 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6813 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6815 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6817 else if (hash_mode
== 6400)
6819 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6821 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6823 else if (hash_mode
== 6500)
6825 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6827 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6829 else if (hash_mode
== 6600)
6831 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6833 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6835 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6836 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6838 uint buf_len
= len
- 1;
6840 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6843 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6845 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6850 else if (hash_mode
== 6700)
6852 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6854 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6856 else if (hash_mode
== 6800)
6858 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6860 else if (hash_mode
== 7100)
6862 uint
*ptr
= digest_buf
;
6864 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6866 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6870 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6871 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6872 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6873 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6874 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6875 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6876 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6877 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6879 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",
6880 SIGNATURE_SHA512OSX
,
6882 esalt
[ 0], esalt
[ 1],
6883 esalt
[ 2], esalt
[ 3],
6884 esalt
[ 4], esalt
[ 5],
6885 esalt
[ 6], esalt
[ 7],
6893 ptr
[15], ptr
[14]);
6895 else if (hash_mode
== 7200)
6897 uint
*ptr
= digest_buf
;
6899 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6901 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6905 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6907 len_used
= strlen (out_buf
);
6909 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6911 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6913 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6916 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",
6924 ptr
[15], ptr
[14]);
6926 else if (hash_mode
== 7300)
6928 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6930 rakp_t
*rakp
= &rakps
[salt_pos
];
6932 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6934 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6937 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6944 else if (hash_mode
== 7400)
6946 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6948 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6949 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6950 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6951 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6952 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6953 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6954 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6955 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6957 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6959 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6961 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6965 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6968 else if (hash_mode
== 7500)
6970 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6972 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6974 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6975 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6979 char *ptr_data
= data
;
6981 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6983 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6986 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6988 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6993 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6995 (char *) krb5pa
->user
,
6996 (char *) krb5pa
->realm
,
6997 (char *) krb5pa
->salt
,
7000 else if (hash_mode
== 7700)
7002 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7003 (char *) salt
.salt_buf
,
7007 else if (hash_mode
== 7800)
7009 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7010 (char *) salt
.salt_buf
,
7017 else if (hash_mode
== 7900)
7019 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7023 char *tmp
= (char *) salt
.salt_buf_pc
;
7025 ptr_plain
[42] = tmp
[0];
7031 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7033 else if (hash_mode
== 8000)
7035 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7036 (unsigned char *) salt
.salt_buf
,
7046 else if (hash_mode
== 8100)
7048 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7049 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7051 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7052 (unsigned char *) salt
.salt_buf
,
7059 else if (hash_mode
== 8200)
7061 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7063 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7065 char data_buf
[4096];
7067 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7069 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7072 data_buf
[cloudkey
->data_len
* 2] = 0;
7074 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7075 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7076 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7077 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7078 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7079 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7080 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7081 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7083 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7084 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7085 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7086 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7088 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7104 else if (hash_mode
== 8300)
7108 char digest_buf_c
[33];
7110 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
7112 digest_buf_c
[32] = 0;
7116 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7118 char domain_buf_c
[33];
7120 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7122 for (uint i
= 0; i
< salt_pc_len
; i
++)
7124 const char next
= domain_buf_c
[i
];
7126 domain_buf_c
[i
] = '.';
7131 domain_buf_c
[salt_pc_len
] = 0;
7135 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7137 else if (hash_mode
== 8500)
7139 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7141 else if (hash_mode
== 2612)
7143 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7145 (char *) salt
.salt_buf
,
7151 else if (hash_mode
== 3711)
7153 char *salt_ptr
= (char *) salt
.salt_buf
;
7155 salt_ptr
[salt
.salt_len
- 1] = 0;
7157 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7158 SIGNATURE_MEDIAWIKI_B
,
7165 else if (hash_mode
== 8800)
7167 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7169 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7173 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7175 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7180 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7181 SIGNATURE_ANDROIDFDE
,
7182 byte_swap_32 (salt
.salt_buf
[0]),
7183 byte_swap_32 (salt
.salt_buf
[1]),
7184 byte_swap_32 (salt
.salt_buf
[2]),
7185 byte_swap_32 (salt
.salt_buf
[3]),
7186 byte_swap_32 (digest_buf
[0]),
7187 byte_swap_32 (digest_buf
[1]),
7188 byte_swap_32 (digest_buf
[2]),
7189 byte_swap_32 (digest_buf
[3]),
7192 else if (hash_mode
== 8900)
7194 uint N
= salt
.scrypt_N
;
7195 uint r
= salt
.scrypt_r
;
7196 uint p
= salt
.scrypt_p
;
7198 char base64_salt
[32];
7200 memset (base64_salt
, 0, 32);
7202 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7204 memset (tmp_buf
, 0, 46);
7206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7211 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7212 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7213 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7214 digest_buf
[8] = 0; // needed for base64_encode ()
7216 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7218 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7226 else if (hash_mode
== 9000)
7228 snprintf (out_buf
, len
-1, "%s", hashfile
);
7230 else if (hash_mode
== 9200)
7234 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7236 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7238 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7242 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7243 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7244 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7245 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7246 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7247 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7248 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7249 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7250 digest_buf
[8] = 0; // needed for base64_encode ()
7253 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7255 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7256 tmp_buf
[43] = 0; // cut it here
7260 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7262 else if (hash_mode
== 9300)
7264 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7265 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7266 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7267 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7268 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7269 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7270 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7271 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7272 digest_buf
[8] = 0; // needed for base64_encode ()
7275 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7277 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7278 tmp_buf
[43] = 0; // cut it here
7280 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7282 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7284 else if (hash_mode
== 9400)
7286 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7288 office2007_t
*office2007
= &office2007s
[salt_pos
];
7290 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7291 SIGNATURE_OFFICE2007
,
7294 office2007
->keySize
,
7300 office2007
->encryptedVerifier
[0],
7301 office2007
->encryptedVerifier
[1],
7302 office2007
->encryptedVerifier
[2],
7303 office2007
->encryptedVerifier
[3],
7304 office2007
->encryptedVerifierHash
[0],
7305 office2007
->encryptedVerifierHash
[1],
7306 office2007
->encryptedVerifierHash
[2],
7307 office2007
->encryptedVerifierHash
[3],
7308 office2007
->encryptedVerifierHash
[4]);
7310 else if (hash_mode
== 9500)
7312 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7314 office2010_t
*office2010
= &office2010s
[salt_pos
];
7316 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,
7322 office2010
->encryptedVerifier
[0],
7323 office2010
->encryptedVerifier
[1],
7324 office2010
->encryptedVerifier
[2],
7325 office2010
->encryptedVerifier
[3],
7326 office2010
->encryptedVerifierHash
[0],
7327 office2010
->encryptedVerifierHash
[1],
7328 office2010
->encryptedVerifierHash
[2],
7329 office2010
->encryptedVerifierHash
[3],
7330 office2010
->encryptedVerifierHash
[4],
7331 office2010
->encryptedVerifierHash
[5],
7332 office2010
->encryptedVerifierHash
[6],
7333 office2010
->encryptedVerifierHash
[7]);
7335 else if (hash_mode
== 9600)
7337 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7339 office2013_t
*office2013
= &office2013s
[salt_pos
];
7341 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,
7347 office2013
->encryptedVerifier
[0],
7348 office2013
->encryptedVerifier
[1],
7349 office2013
->encryptedVerifier
[2],
7350 office2013
->encryptedVerifier
[3],
7351 office2013
->encryptedVerifierHash
[0],
7352 office2013
->encryptedVerifierHash
[1],
7353 office2013
->encryptedVerifierHash
[2],
7354 office2013
->encryptedVerifierHash
[3],
7355 office2013
->encryptedVerifierHash
[4],
7356 office2013
->encryptedVerifierHash
[5],
7357 office2013
->encryptedVerifierHash
[6],
7358 office2013
->encryptedVerifierHash
[7]);
7360 else if (hash_mode
== 9700)
7362 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7364 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7366 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7367 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7368 byte_swap_32 (salt
.salt_buf
[0]),
7369 byte_swap_32 (salt
.salt_buf
[1]),
7370 byte_swap_32 (salt
.salt_buf
[2]),
7371 byte_swap_32 (salt
.salt_buf
[3]),
7372 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7373 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7374 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7375 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7376 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7377 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7378 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7379 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7381 else if (hash_mode
== 9710)
7383 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7385 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7387 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7388 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7389 byte_swap_32 (salt
.salt_buf
[0]),
7390 byte_swap_32 (salt
.salt_buf
[1]),
7391 byte_swap_32 (salt
.salt_buf
[2]),
7392 byte_swap_32 (salt
.salt_buf
[3]),
7393 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7394 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7395 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7396 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7397 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7398 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7400 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7402 else if (hash_mode
== 9720)
7404 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7406 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7408 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7410 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7411 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7412 byte_swap_32 (salt
.salt_buf
[0]),
7413 byte_swap_32 (salt
.salt_buf
[1]),
7414 byte_swap_32 (salt
.salt_buf
[2]),
7415 byte_swap_32 (salt
.salt_buf
[3]),
7416 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7417 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7418 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7419 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7420 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7421 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7430 else if (hash_mode
== 9800)
7432 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7434 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7436 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7437 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7442 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7443 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7444 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7445 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7446 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7447 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7448 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7449 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7450 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7452 else if (hash_mode
== 9810)
7454 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7456 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7458 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7459 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7464 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7465 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7466 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7467 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7468 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7469 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7470 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7471 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7472 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7474 else if (hash_mode
== 9820)
7476 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7478 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7480 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7482 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7483 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7488 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7489 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7490 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7491 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7492 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7493 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7494 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7503 else if (hash_mode
== 10000)
7507 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7509 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7511 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7515 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7516 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7517 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7518 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7519 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7520 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7521 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7522 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7523 digest_buf
[8] = 0; // needed for base64_encode ()
7526 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7528 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7532 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7534 else if (hash_mode
== 10100)
7536 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7541 byte_swap_32 (salt
.salt_buf
[0]),
7542 byte_swap_32 (salt
.salt_buf
[1]),
7543 byte_swap_32 (salt
.salt_buf
[2]),
7544 byte_swap_32 (salt
.salt_buf
[3]));
7546 else if (hash_mode
== 10200)
7548 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7550 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7554 char challenge
[100];
7556 memset (challenge
, 0, sizeof (challenge
));
7558 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7564 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7565 (char *) cram_md5
->user
,
7573 memset (response
, 0, sizeof (response
));
7575 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7577 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7579 else if (hash_mode
== 10300)
7583 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7585 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7586 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7588 uint tmp_len
= 20 + salt
.salt_len
;
7592 char base64_encoded
[100];
7594 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7596 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7598 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7600 else if (hash_mode
== 10400)
7602 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7604 pdf_t
*pdf
= &pdfs
[salt_pos
];
7606 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",
7614 byte_swap_32 (pdf
->id_buf
[0]),
7615 byte_swap_32 (pdf
->id_buf
[1]),
7616 byte_swap_32 (pdf
->id_buf
[2]),
7617 byte_swap_32 (pdf
->id_buf
[3]),
7619 byte_swap_32 (pdf
->u_buf
[0]),
7620 byte_swap_32 (pdf
->u_buf
[1]),
7621 byte_swap_32 (pdf
->u_buf
[2]),
7622 byte_swap_32 (pdf
->u_buf
[3]),
7623 byte_swap_32 (pdf
->u_buf
[4]),
7624 byte_swap_32 (pdf
->u_buf
[5]),
7625 byte_swap_32 (pdf
->u_buf
[6]),
7626 byte_swap_32 (pdf
->u_buf
[7]),
7628 byte_swap_32 (pdf
->o_buf
[0]),
7629 byte_swap_32 (pdf
->o_buf
[1]),
7630 byte_swap_32 (pdf
->o_buf
[2]),
7631 byte_swap_32 (pdf
->o_buf
[3]),
7632 byte_swap_32 (pdf
->o_buf
[4]),
7633 byte_swap_32 (pdf
->o_buf
[5]),
7634 byte_swap_32 (pdf
->o_buf
[6]),
7635 byte_swap_32 (pdf
->o_buf
[7])
7638 else if (hash_mode
== 10410)
7640 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7642 pdf_t
*pdf
= &pdfs
[salt_pos
];
7644 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",
7652 byte_swap_32 (pdf
->id_buf
[0]),
7653 byte_swap_32 (pdf
->id_buf
[1]),
7654 byte_swap_32 (pdf
->id_buf
[2]),
7655 byte_swap_32 (pdf
->id_buf
[3]),
7657 byte_swap_32 (pdf
->u_buf
[0]),
7658 byte_swap_32 (pdf
->u_buf
[1]),
7659 byte_swap_32 (pdf
->u_buf
[2]),
7660 byte_swap_32 (pdf
->u_buf
[3]),
7661 byte_swap_32 (pdf
->u_buf
[4]),
7662 byte_swap_32 (pdf
->u_buf
[5]),
7663 byte_swap_32 (pdf
->u_buf
[6]),
7664 byte_swap_32 (pdf
->u_buf
[7]),
7666 byte_swap_32 (pdf
->o_buf
[0]),
7667 byte_swap_32 (pdf
->o_buf
[1]),
7668 byte_swap_32 (pdf
->o_buf
[2]),
7669 byte_swap_32 (pdf
->o_buf
[3]),
7670 byte_swap_32 (pdf
->o_buf
[4]),
7671 byte_swap_32 (pdf
->o_buf
[5]),
7672 byte_swap_32 (pdf
->o_buf
[6]),
7673 byte_swap_32 (pdf
->o_buf
[7])
7676 else if (hash_mode
== 10420)
7678 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7680 pdf_t
*pdf
= &pdfs
[salt_pos
];
7682 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7684 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",
7692 byte_swap_32 (pdf
->id_buf
[0]),
7693 byte_swap_32 (pdf
->id_buf
[1]),
7694 byte_swap_32 (pdf
->id_buf
[2]),
7695 byte_swap_32 (pdf
->id_buf
[3]),
7697 byte_swap_32 (pdf
->u_buf
[0]),
7698 byte_swap_32 (pdf
->u_buf
[1]),
7699 byte_swap_32 (pdf
->u_buf
[2]),
7700 byte_swap_32 (pdf
->u_buf
[3]),
7701 byte_swap_32 (pdf
->u_buf
[4]),
7702 byte_swap_32 (pdf
->u_buf
[5]),
7703 byte_swap_32 (pdf
->u_buf
[6]),
7704 byte_swap_32 (pdf
->u_buf
[7]),
7706 byte_swap_32 (pdf
->o_buf
[0]),
7707 byte_swap_32 (pdf
->o_buf
[1]),
7708 byte_swap_32 (pdf
->o_buf
[2]),
7709 byte_swap_32 (pdf
->o_buf
[3]),
7710 byte_swap_32 (pdf
->o_buf
[4]),
7711 byte_swap_32 (pdf
->o_buf
[5]),
7712 byte_swap_32 (pdf
->o_buf
[6]),
7713 byte_swap_32 (pdf
->o_buf
[7]),
7721 else if (hash_mode
== 10500)
7723 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7725 pdf_t
*pdf
= &pdfs
[salt_pos
];
7727 if (pdf
->id_len
== 32)
7729 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",
7737 byte_swap_32 (pdf
->id_buf
[0]),
7738 byte_swap_32 (pdf
->id_buf
[1]),
7739 byte_swap_32 (pdf
->id_buf
[2]),
7740 byte_swap_32 (pdf
->id_buf
[3]),
7741 byte_swap_32 (pdf
->id_buf
[4]),
7742 byte_swap_32 (pdf
->id_buf
[5]),
7743 byte_swap_32 (pdf
->id_buf
[6]),
7744 byte_swap_32 (pdf
->id_buf
[7]),
7746 byte_swap_32 (pdf
->u_buf
[0]),
7747 byte_swap_32 (pdf
->u_buf
[1]),
7748 byte_swap_32 (pdf
->u_buf
[2]),
7749 byte_swap_32 (pdf
->u_buf
[3]),
7750 byte_swap_32 (pdf
->u_buf
[4]),
7751 byte_swap_32 (pdf
->u_buf
[5]),
7752 byte_swap_32 (pdf
->u_buf
[6]),
7753 byte_swap_32 (pdf
->u_buf
[7]),
7755 byte_swap_32 (pdf
->o_buf
[0]),
7756 byte_swap_32 (pdf
->o_buf
[1]),
7757 byte_swap_32 (pdf
->o_buf
[2]),
7758 byte_swap_32 (pdf
->o_buf
[3]),
7759 byte_swap_32 (pdf
->o_buf
[4]),
7760 byte_swap_32 (pdf
->o_buf
[5]),
7761 byte_swap_32 (pdf
->o_buf
[6]),
7762 byte_swap_32 (pdf
->o_buf
[7])
7767 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",
7775 byte_swap_32 (pdf
->id_buf
[0]),
7776 byte_swap_32 (pdf
->id_buf
[1]),
7777 byte_swap_32 (pdf
->id_buf
[2]),
7778 byte_swap_32 (pdf
->id_buf
[3]),
7780 byte_swap_32 (pdf
->u_buf
[0]),
7781 byte_swap_32 (pdf
->u_buf
[1]),
7782 byte_swap_32 (pdf
->u_buf
[2]),
7783 byte_swap_32 (pdf
->u_buf
[3]),
7784 byte_swap_32 (pdf
->u_buf
[4]),
7785 byte_swap_32 (pdf
->u_buf
[5]),
7786 byte_swap_32 (pdf
->u_buf
[6]),
7787 byte_swap_32 (pdf
->u_buf
[7]),
7789 byte_swap_32 (pdf
->o_buf
[0]),
7790 byte_swap_32 (pdf
->o_buf
[1]),
7791 byte_swap_32 (pdf
->o_buf
[2]),
7792 byte_swap_32 (pdf
->o_buf
[3]),
7793 byte_swap_32 (pdf
->o_buf
[4]),
7794 byte_swap_32 (pdf
->o_buf
[5]),
7795 byte_swap_32 (pdf
->o_buf
[6]),
7796 byte_swap_32 (pdf
->o_buf
[7])
7800 else if (hash_mode
== 10600)
7802 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7804 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7805 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7807 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7809 else if (hash_mode
== 10700)
7811 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7813 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7814 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7816 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7818 else if (hash_mode
== 10900)
7820 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7822 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7823 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7825 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7827 else if (hash_mode
== 11100)
7829 uint32_t salt_challenge
= salt
.salt_buf
[0];
7831 salt_challenge
= byte_swap_32 (salt_challenge
);
7833 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7835 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7836 SIGNATURE_POSTGRESQL_AUTH
,
7844 else if (hash_mode
== 11200)
7846 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7847 SIGNATURE_MYSQL_AUTH
,
7848 (unsigned char *) salt
.salt_buf
,
7855 else if (hash_mode
== 11300)
7857 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7859 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7861 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7862 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7863 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7865 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7866 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7867 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7869 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7871 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7873 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7876 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7878 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7880 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7883 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7885 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7887 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7890 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7891 SIGNATURE_BITCOIN_WALLET
,
7895 (unsigned char *) salt
.salt_buf
,
7903 free (cry_master_buf
);
7905 free (public_key_buf
);
7907 else if (hash_mode
== 11400)
7909 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7911 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7912 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7914 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7916 else if (hash_mode
== 11600)
7918 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7920 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7922 const uint data_len
= seven_zip
->data_len
;
7924 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7926 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7928 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7930 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7933 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7934 SIGNATURE_SEVEN_ZIP
,
7938 (char *) seven_zip
->salt_buf
,
7940 seven_zip
->iv_buf
[0],
7941 seven_zip
->iv_buf
[1],
7942 seven_zip
->iv_buf
[2],
7943 seven_zip
->iv_buf
[3],
7945 seven_zip
->data_len
,
7946 seven_zip
->unpack_size
,
7951 else if (hash_mode
== 11700)
7953 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7963 else if (hash_mode
== 11800)
7965 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7983 else if (hash_mode
== 11900)
7985 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7987 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7988 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7990 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7992 else if (hash_mode
== 12000)
7994 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7996 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7997 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7999 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8001 else if (hash_mode
== 12100)
8003 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8005 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8006 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8008 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8010 else if (hash_mode
== 12200)
8012 uint
*ptr_digest
= digest_buf
;
8013 uint
*ptr_salt
= salt
.salt_buf
;
8015 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8022 else if (hash_mode
== 12300)
8024 uint
*ptr_digest
= digest_buf
;
8025 uint
*ptr_salt
= salt
.salt_buf
;
8027 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",
8028 ptr_digest
[ 0], ptr_digest
[ 1],
8029 ptr_digest
[ 2], ptr_digest
[ 3],
8030 ptr_digest
[ 4], ptr_digest
[ 5],
8031 ptr_digest
[ 6], ptr_digest
[ 7],
8032 ptr_digest
[ 8], ptr_digest
[ 9],
8033 ptr_digest
[10], ptr_digest
[11],
8034 ptr_digest
[12], ptr_digest
[13],
8035 ptr_digest
[14], ptr_digest
[15],
8041 else if (hash_mode
== 12400)
8043 // encode iteration count
8047 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8048 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8049 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8050 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8055 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8056 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8057 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8058 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8063 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8065 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8066 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8068 memcpy (tmp_buf
, digest_buf
, 8);
8070 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
8074 // fill the resulting buffer
8076 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8078 else if (hash_mode
== 12500)
8080 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8082 byte_swap_32 (salt
.salt_buf
[0]),
8083 byte_swap_32 (salt
.salt_buf
[1]),
8089 else if (hash_mode
== 12600)
8091 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8092 digest_buf
[0] + salt
.salt_buf_pc
[0],
8093 digest_buf
[1] + salt
.salt_buf_pc
[1],
8094 digest_buf
[2] + salt
.salt_buf_pc
[2],
8095 digest_buf
[3] + salt
.salt_buf_pc
[3],
8096 digest_buf
[4] + salt
.salt_buf_pc
[4],
8097 digest_buf
[5] + salt
.salt_buf_pc
[5],
8098 digest_buf
[6] + salt
.salt_buf_pc
[6],
8099 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8101 else if (hash_mode
== 12700)
8103 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8105 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8106 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8108 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8110 else if (hash_mode
== 12800)
8112 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
8114 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",
8127 byte_swap_32 (digest_buf
[0]),
8128 byte_swap_32 (digest_buf
[1]),
8129 byte_swap_32 (digest_buf
[2]),
8130 byte_swap_32 (digest_buf
[3]),
8131 byte_swap_32 (digest_buf
[4]),
8132 byte_swap_32 (digest_buf
[5]),
8133 byte_swap_32 (digest_buf
[6]),
8134 byte_swap_32 (digest_buf
[7])
8137 else if (hash_mode
== 12900)
8139 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",
8148 byte_swap_32 (digest_buf
[0]),
8149 byte_swap_32 (digest_buf
[1]),
8150 byte_swap_32 (digest_buf
[2]),
8151 byte_swap_32 (digest_buf
[3]),
8152 byte_swap_32 (digest_buf
[4]),
8153 byte_swap_32 (digest_buf
[5]),
8154 byte_swap_32 (digest_buf
[6]),
8155 byte_swap_32 (digest_buf
[7]),
8162 else if (hash_mode
== 13000)
8164 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8166 rar5_t
*rar5
= &rar5s
[salt_pos
];
8168 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8178 byte_swap_32 (digest_buf
[0]),
8179 byte_swap_32 (digest_buf
[1])
8184 if (hash_type
== HASH_TYPE_MD4
)
8186 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8192 else if (hash_type
== HASH_TYPE_MD5
)
8194 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8200 else if (hash_type
== HASH_TYPE_SHA1
)
8202 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8209 else if (hash_type
== HASH_TYPE_SHA256
)
8211 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8221 else if (hash_type
== HASH_TYPE_SHA384
)
8223 uint
*ptr
= digest_buf
;
8225 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8233 else if (hash_type
== HASH_TYPE_SHA512
)
8235 uint
*ptr
= digest_buf
;
8237 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8247 else if (hash_type
== HASH_TYPE_LM
)
8249 snprintf (out_buf
, len
-1, "%08x%08x",
8253 else if (hash_type
== HASH_TYPE_ORACLEH
)
8255 snprintf (out_buf
, len
-1, "%08X%08X",
8259 else if (hash_type
== HASH_TYPE_BCRYPT
)
8261 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8262 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8264 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8266 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8268 else if (hash_type
== HASH_TYPE_KECCAK
)
8270 uint
*ptr
= digest_buf
;
8272 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",
8300 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8302 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8304 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8311 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8313 digest_buf
[ 0] = digest_buf
[ 0];
8314 digest_buf
[ 1] = digest_buf
[ 1];
8315 digest_buf
[ 2] = digest_buf
[ 2];
8316 digest_buf
[ 3] = digest_buf
[ 3];
8317 digest_buf
[ 4] = digest_buf
[ 4];
8318 digest_buf
[ 5] = digest_buf
[ 5];
8319 digest_buf
[ 6] = digest_buf
[ 6];
8320 digest_buf
[ 7] = digest_buf
[ 7];
8321 digest_buf
[ 8] = digest_buf
[ 8];
8322 digest_buf
[ 9] = digest_buf
[ 9];
8323 digest_buf
[10] = digest_buf
[10];
8324 digest_buf
[11] = digest_buf
[11];
8325 digest_buf
[12] = digest_buf
[12];
8326 digest_buf
[13] = digest_buf
[13];
8327 digest_buf
[14] = digest_buf
[14];
8328 digest_buf
[15] = digest_buf
[15];
8330 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8348 else if (hash_type
== HASH_TYPE_GOST
)
8350 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8360 else if (hash_type
== HASH_TYPE_MYSQL
)
8362 snprintf (out_buf
, len
-1, "%08x%08x",
8366 else if (hash_type
== HASH_TYPE_LOTUS5
)
8368 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8374 else if (hash_type
== HASH_TYPE_LOTUS6
)
8376 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8377 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8378 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8379 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8383 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8384 memcpy (buf
+ 5, digest_buf
, 9);
8388 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8390 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8393 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8395 else if (hash_type
== HASH_TYPE_LOTUS8
)
8399 memset (buf
, 0, sizeof (buf
));
8403 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8409 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8413 buf
[26] = salt
.salt_buf_pc
[0];
8414 buf
[27] = salt
.salt_buf_pc
[1];
8418 memcpy (buf
+ 28, digest_buf
, 8);
8420 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8424 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8426 else if (hash_type
== HASH_TYPE_CRC32
)
8428 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8432 if (salt_type
== SALT_TYPE_INTERN
)
8434 size_t pos
= strlen (out_buf
);
8436 out_buf
[pos
] = data
.separator
;
8438 char *ptr
= (char *) salt
.salt_buf
;
8440 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8442 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8446 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8448 memset (hccap
, 0, sizeof (hccap_t
));
8450 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8452 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8454 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8455 wpa_t
*wpa
= &wpas
[salt_pos
];
8457 hccap
->keyver
= wpa
->keyver
;
8459 hccap
->eapol_size
= wpa
->eapol_size
;
8461 if (wpa
->keyver
!= 1)
8465 for (uint i
= 0; i
< 64; i
++)
8467 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8470 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8474 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8479 for (int i
= 5; i
< 25; i
++)
8481 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8484 char *pke_ptr
= (char *) pke_tmp
;
8486 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8487 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8488 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8489 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8491 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8493 uint dgst_size
= data
.dgst_size
;
8495 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8497 if (wpa
->keyver
!= 1)
8501 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8502 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8503 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8504 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8506 memcpy (hccap
->keymic
, digest_tmp
, 16);
8510 memcpy (hccap
->keymic
, digest_ptr
, 16);
8514 void SuspendThreads ()
8516 if (data
.devices_status
== STATUS_RUNNING
)
8518 hc_timer_set (&data
.timer_paused
);
8520 data
.devices_status
= STATUS_PAUSED
;
8522 log_info ("Paused");
8526 void ResumeThreads ()
8528 if (data
.devices_status
== STATUS_PAUSED
)
8532 hc_timer_get (data
.timer_paused
, ms_paused
);
8534 data
.ms_paused
+= ms_paused
;
8536 data
.devices_status
= STATUS_RUNNING
;
8538 log_info ("Resumed");
8544 if (data
.devices_status
!= STATUS_RUNNING
) return;
8546 data
.devices_status
= STATUS_BYPASS
;
8548 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8551 void stop_at_checkpoint ()
8553 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8555 if (data
.devices_status
!= STATUS_RUNNING
) return;
8558 // this feature only makes sense if --restore-disable was not specified
8560 if (data
.restore_disable
== 1)
8562 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8567 // check if monitoring of Restore Point updates should be enabled or disabled
8569 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8571 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8573 // save the current restore point value
8575 data
.checkpoint_cur_words
= get_lowest_words_done ();
8577 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8581 data
.devices_status
= STATUS_RUNNING
;
8583 // reset the global value for checkpoint checks
8585 data
.checkpoint_cur_words
= 0;
8587 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8593 if (data
.devices_status
== STATUS_INIT
) return;
8594 if (data
.devices_status
== STATUS_STARTING
) return;
8596 data
.devices_status
= STATUS_ABORTED
;
8601 if (data
.devices_status
== STATUS_INIT
) return;
8602 if (data
.devices_status
== STATUS_STARTING
) return;
8604 data
.devices_status
= STATUS_QUIT
;
8607 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8611 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8615 memset (&st
, 0, sizeof (st
));
8617 stat (kernel_file
, &st
);
8619 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8621 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8623 if (num_read
!= (size_t) st
.st_size
)
8625 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8632 buf
[st
.st_size
] = 0;
8634 for (int i
= 0; i
< num_devices
; i
++)
8636 kernel_lengths
[i
] = (size_t) st
.st_size
;
8638 kernel_sources
[i
] = buf
;
8643 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8651 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8653 FILE *fp
= fopen (dst
, "wb");
8655 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8665 restore_data_t
*init_restore (int argc
, char **argv
)
8667 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8669 if (data
.restore_disable
== 0)
8671 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8675 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8679 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8688 char pidbin
[BUFSIZ
];
8693 memset (pidbin
, 0, sizeof (pidbin
));
8695 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8697 FILE *fd
= fopen (pidbin
, "rb");
8701 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8703 pidbin
[pidbin_len
] = 0;
8707 char *argv0_r
= strrchr (argv
[0], '/');
8709 char *pidbin_r
= strrchr (pidbin
, '/');
8711 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8713 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8715 if (strcmp (argv0_r
, pidbin_r
) == 0)
8717 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8724 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8726 char pidbin2
[BUFSIZ
];
8730 memset (pidbin2
, 0, sizeof (pidbin2
));
8732 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8733 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8735 pidbin
[pidbin_len
] = 0;
8736 pidbin2
[pidbin2_len
] = 0;
8740 if (strcmp (pidbin
, pidbin2
) == 0)
8742 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8750 if (rd
->version_bin
< RESTORE_MIN
)
8752 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8759 memset (rd
, 0, sizeof (restore_data_t
));
8761 rd
->version_bin
= VERSION_BIN
;
8764 rd
->pid
= getpid ();
8766 rd
->pid
= GetCurrentProcessId ();
8769 if (getcwd (rd
->cwd
, 255) == NULL
)
8782 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8784 FILE *fp
= fopen (eff_restore_file
, "rb");
8788 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8793 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8795 log_error ("ERROR: cannot read %s", eff_restore_file
);
8800 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8802 for (uint i
= 0; i
< rd
->argc
; i
++)
8806 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8808 log_error ("ERROR: cannot read %s", eff_restore_file
);
8813 size_t len
= strlen (buf
);
8815 if (len
) buf
[len
- 1] = 0;
8817 rd
->argv
[i
] = mystrdup (buf
);
8824 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8828 log_error ("Restore file is corrupted");
8831 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8833 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8835 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8840 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8844 if (chdir (rd
->cwd
))
8846 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8852 uint64_t get_lowest_words_done ()
8854 uint64_t words_cur
= -1;
8856 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8858 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8860 const uint64_t words_done
= device_param
->words_done
;
8862 if (words_done
< words_cur
) words_cur
= words_done
;
8865 // It's possible that a device's workload isn't finished right after a restore-case.
8866 // In that case, this function would return 0 and overwrite the real restore point
8867 // There's also data.words_cur which is set to rd->words_cur but it changes while
8868 // the attack is running therefore we should stick to rd->words_cur.
8869 // Note that -s influences rd->words_cur we should keep a close look on that.
8871 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8876 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8878 uint64_t words_cur
= get_lowest_words_done ();
8880 rd
->words_cur
= words_cur
;
8882 FILE *fp
= fopen (new_restore_file
, "wb");
8886 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8891 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8893 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8898 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8900 for (uint i
= 0; i
< rd
->argc
; i
++)
8902 fprintf (fp
, "%s", rd
->argv
[i
]);
8908 fsync (fileno (fp
));
8913 void cycle_restore ()
8915 const char *eff_restore_file
= data
.eff_restore_file
;
8916 const char *new_restore_file
= data
.new_restore_file
;
8918 restore_data_t
*rd
= data
.rd
;
8920 write_restore (new_restore_file
, rd
);
8924 memset (&st
, 0, sizeof(st
));
8926 if (stat (eff_restore_file
, &st
) == 0)
8928 if (unlink (eff_restore_file
))
8930 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8934 if (rename (new_restore_file
, eff_restore_file
))
8936 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8940 void check_checkpoint ()
8942 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8944 uint64_t words_cur
= get_lowest_words_done ();
8946 if (words_cur
!= data
.checkpoint_cur_words
)
8956 uint
set_kernel_accel (uint hash_mode
)
8960 case 0: return GET_ACCEL (0);
8961 case 10: return GET_ACCEL (10);
8962 case 11: return GET_ACCEL (11);
8963 case 12: return GET_ACCEL (12);
8964 case 20: return GET_ACCEL (20);
8965 case 21: return GET_ACCEL (21);
8966 case 22: return GET_ACCEL (22);
8967 case 23: return GET_ACCEL (23);
8968 case 30: return GET_ACCEL (30);
8969 case 40: return GET_ACCEL (40);
8970 case 50: return GET_ACCEL (50);
8971 case 60: return GET_ACCEL (60);
8972 case 100: return GET_ACCEL (100);
8973 case 101: return GET_ACCEL (101);
8974 case 110: return GET_ACCEL (110);
8975 case 111: return GET_ACCEL (111);
8976 case 112: return GET_ACCEL (112);
8977 case 120: return GET_ACCEL (120);
8978 case 121: return GET_ACCEL (121);
8979 case 122: return GET_ACCEL (122);
8980 case 124: return GET_ACCEL (124);
8981 case 130: return GET_ACCEL (130);
8982 case 131: return GET_ACCEL (131);
8983 case 132: return GET_ACCEL (132);
8984 case 133: return GET_ACCEL (133);
8985 case 140: return GET_ACCEL (140);
8986 case 141: return GET_ACCEL (141);
8987 case 150: return GET_ACCEL (150);
8988 case 160: return GET_ACCEL (160);
8989 case 190: return GET_ACCEL (190);
8990 case 200: return GET_ACCEL (200);
8991 case 300: return GET_ACCEL (300);
8992 case 400: return GET_ACCEL (400);
8993 case 500: return GET_ACCEL (500);
8994 case 501: return GET_ACCEL (501);
8995 case 900: return GET_ACCEL (900);
8996 case 910: return GET_ACCEL (910);
8997 case 1000: return GET_ACCEL (1000);
8998 case 1100: return GET_ACCEL (1100);
8999 case 1400: return GET_ACCEL (1400);
9000 case 1410: return GET_ACCEL (1410);
9001 case 1420: return GET_ACCEL (1420);
9002 case 1421: return GET_ACCEL (1421);
9003 case 1430: return GET_ACCEL (1430);
9004 case 1440: return GET_ACCEL (1440);
9005 case 1441: return GET_ACCEL (1441);
9006 case 1450: return GET_ACCEL (1450);
9007 case 1460: return GET_ACCEL (1460);
9008 case 1500: return GET_ACCEL (1500);
9009 case 1600: return GET_ACCEL (1600);
9010 case 1700: return GET_ACCEL (1700);
9011 case 1710: return GET_ACCEL (1710);
9012 case 1711: return GET_ACCEL (1711);
9013 case 1720: return GET_ACCEL (1720);
9014 case 1722: return GET_ACCEL (1722);
9015 case 1730: return GET_ACCEL (1730);
9016 case 1731: return GET_ACCEL (1731);
9017 case 1740: return GET_ACCEL (1740);
9018 case 1750: return GET_ACCEL (1750);
9019 case 1760: return GET_ACCEL (1760);
9020 case 1800: return GET_ACCEL (1800);
9021 case 2100: return GET_ACCEL (2100);
9022 case 2400: return GET_ACCEL (2400);
9023 case 2410: return GET_ACCEL (2410);
9024 case 2500: return GET_ACCEL (2500);
9025 case 2600: return GET_ACCEL (2600);
9026 case 2611: return GET_ACCEL (2611);
9027 case 2612: return GET_ACCEL (2612);
9028 case 2711: return GET_ACCEL (2711);
9029 case 2811: return GET_ACCEL (2811);
9030 case 3000: return GET_ACCEL (3000);
9031 case 3100: return GET_ACCEL (3100);
9032 case 3200: return GET_ACCEL (3200);
9033 case 3710: return GET_ACCEL (3710);
9034 case 3711: return GET_ACCEL (3711);
9035 case 3800: return GET_ACCEL (3800);
9036 case 4300: return GET_ACCEL (4300);
9037 case 4400: return GET_ACCEL (4400);
9038 case 4500: return GET_ACCEL (4500);
9039 case 4700: return GET_ACCEL (4700);
9040 case 4800: return GET_ACCEL (4800);
9041 case 4900: return GET_ACCEL (4900);
9042 case 5000: return GET_ACCEL (5000);
9043 case 5100: return GET_ACCEL (5100);
9044 case 5200: return GET_ACCEL (5200);
9045 case 5300: return GET_ACCEL (5300);
9046 case 5400: return GET_ACCEL (5400);
9047 case 5500: return GET_ACCEL (5500);
9048 case 5600: return GET_ACCEL (5600);
9049 case 5700: return GET_ACCEL (5700);
9050 case 5800: return GET_ACCEL (5800);
9051 case 6000: return GET_ACCEL (6000);
9052 case 6100: return GET_ACCEL (6100);
9053 case 6211: return GET_ACCEL (6211);
9054 case 6212: return GET_ACCEL (6212);
9055 case 6213: return GET_ACCEL (6213);
9056 case 6221: return GET_ACCEL (6221);
9057 case 6222: return GET_ACCEL (6222);
9058 case 6223: return GET_ACCEL (6223);
9059 case 6231: return GET_ACCEL (6231);
9060 case 6232: return GET_ACCEL (6232);
9061 case 6233: return GET_ACCEL (6233);
9062 case 6241: return GET_ACCEL (6241);
9063 case 6242: return GET_ACCEL (6242);
9064 case 6243: return GET_ACCEL (6243);
9065 case 6300: return GET_ACCEL (6300);
9066 case 6400: return GET_ACCEL (6400);
9067 case 6500: return GET_ACCEL (6500);
9068 case 6600: return GET_ACCEL (6600);
9069 case 6700: return GET_ACCEL (6700);
9070 case 6800: return GET_ACCEL (6800);
9071 case 6900: return GET_ACCEL (6900);
9072 case 7100: return GET_ACCEL (7100);
9073 case 7200: return GET_ACCEL (7200);
9074 case 7300: return GET_ACCEL (7300);
9075 case 7400: return GET_ACCEL (7400);
9076 case 7500: return GET_ACCEL (7500);
9077 case 7600: return GET_ACCEL (7600);
9078 case 7700: return GET_ACCEL (7700);
9079 case 7800: return GET_ACCEL (7800);
9080 case 7900: return GET_ACCEL (7900);
9081 case 8000: return GET_ACCEL (8000);
9082 case 8100: return GET_ACCEL (8100);
9083 case 8200: return GET_ACCEL (8200);
9084 case 8300: return GET_ACCEL (8300);
9085 case 8400: return GET_ACCEL (8400);
9086 case 8500: return GET_ACCEL (8500);
9087 case 8600: return GET_ACCEL (8600);
9088 case 8700: return GET_ACCEL (8700);
9089 case 8800: return GET_ACCEL (8800);
9090 case 8900: return GET_ACCEL (8900);
9091 case 9000: return GET_ACCEL (9000);
9092 case 9100: return GET_ACCEL (9100);
9093 case 9200: return GET_ACCEL (9200);
9094 case 9300: return GET_ACCEL (9300);
9095 case 9400: return GET_ACCEL (9400);
9096 case 9500: return GET_ACCEL (9500);
9097 case 9600: return GET_ACCEL (9600);
9098 case 9700: return GET_ACCEL (9700);
9099 case 9710: return GET_ACCEL (9710);
9100 case 9720: return GET_ACCEL (9720);
9101 case 9800: return GET_ACCEL (9800);
9102 case 9810: return GET_ACCEL (9810);
9103 case 9820: return GET_ACCEL (9820);
9104 case 9900: return GET_ACCEL (9900);
9105 case 10000: return GET_ACCEL (10000);
9106 case 10100: return GET_ACCEL (10100);
9107 case 10200: return GET_ACCEL (10200);
9108 case 10300: return GET_ACCEL (10300);
9109 case 10400: return GET_ACCEL (10400);
9110 case 10410: return GET_ACCEL (10410);
9111 case 10420: return GET_ACCEL (10420);
9112 case 10500: return GET_ACCEL (10500);
9113 case 10600: return GET_ACCEL (10600);
9114 case 10700: return GET_ACCEL (10700);
9115 case 10800: return GET_ACCEL (10800);
9116 case 10900: return GET_ACCEL (10900);
9117 case 11000: return GET_ACCEL (11000);
9118 case 11100: return GET_ACCEL (11100);
9119 case 11200: return GET_ACCEL (11200);
9120 case 11300: return GET_ACCEL (11300);
9121 case 11400: return GET_ACCEL (11400);
9122 case 11500: return GET_ACCEL (11500);
9123 case 11600: return GET_ACCEL (11600);
9124 case 11700: return GET_ACCEL (11700);
9125 case 11800: return GET_ACCEL (11800);
9126 case 11900: return GET_ACCEL (11900);
9127 case 12000: return GET_ACCEL (12000);
9128 case 12100: return GET_ACCEL (12100);
9129 case 12200: return GET_ACCEL (12200);
9130 case 12300: return GET_ACCEL (12300);
9131 case 12400: return GET_ACCEL (12400);
9132 case 12500: return GET_ACCEL (12500);
9133 case 12600: return GET_ACCEL (12600);
9134 case 12700: return GET_ACCEL (12700);
9135 case 12800: return GET_ACCEL (12800);
9136 case 12900: return GET_ACCEL (12900);
9137 case 13000: return GET_ACCEL (13000);
9143 uint
set_kernel_loops (uint hash_mode
)
9147 case 0: return GET_LOOPS (0);
9148 case 10: return GET_LOOPS (10);
9149 case 11: return GET_LOOPS (11);
9150 case 12: return GET_LOOPS (12);
9151 case 20: return GET_LOOPS (20);
9152 case 21: return GET_LOOPS (21);
9153 case 22: return GET_LOOPS (22);
9154 case 23: return GET_LOOPS (23);
9155 case 30: return GET_LOOPS (30);
9156 case 40: return GET_LOOPS (40);
9157 case 50: return GET_LOOPS (50);
9158 case 60: return GET_LOOPS (60);
9159 case 100: return GET_LOOPS (100);
9160 case 101: return GET_LOOPS (101);
9161 case 110: return GET_LOOPS (110);
9162 case 111: return GET_LOOPS (111);
9163 case 112: return GET_LOOPS (112);
9164 case 120: return GET_LOOPS (120);
9165 case 121: return GET_LOOPS (121);
9166 case 122: return GET_LOOPS (122);
9167 case 124: return GET_LOOPS (124);
9168 case 130: return GET_LOOPS (130);
9169 case 131: return GET_LOOPS (131);
9170 case 132: return GET_LOOPS (132);
9171 case 133: return GET_LOOPS (133);
9172 case 140: return GET_LOOPS (140);
9173 case 141: return GET_LOOPS (141);
9174 case 150: return GET_LOOPS (150);
9175 case 160: return GET_LOOPS (160);
9176 case 190: return GET_LOOPS (190);
9177 case 200: return GET_LOOPS (200);
9178 case 300: return GET_LOOPS (300);
9179 case 400: return GET_LOOPS (400);
9180 case 500: return GET_LOOPS (500);
9181 case 501: return GET_LOOPS (501);
9182 case 900: return GET_LOOPS (900);
9183 case 910: return GET_LOOPS (910);
9184 case 1000: return GET_LOOPS (1000);
9185 case 1100: return GET_LOOPS (1100);
9186 case 1400: return GET_LOOPS (1400);
9187 case 1410: return GET_LOOPS (1410);
9188 case 1420: return GET_LOOPS (1420);
9189 case 1421: return GET_LOOPS (1421);
9190 case 1430: return GET_LOOPS (1430);
9191 case 1440: return GET_LOOPS (1440);
9192 case 1441: return GET_LOOPS (1441);
9193 case 1450: return GET_LOOPS (1450);
9194 case 1460: return GET_LOOPS (1460);
9195 case 1500: return GET_LOOPS (1500);
9196 case 1600: return GET_LOOPS (1600);
9197 case 1700: return GET_LOOPS (1700);
9198 case 1710: return GET_LOOPS (1710);
9199 case 1711: return GET_LOOPS (1711);
9200 case 1720: return GET_LOOPS (1720);
9201 case 1722: return GET_LOOPS (1722);
9202 case 1730: return GET_LOOPS (1730);
9203 case 1731: return GET_LOOPS (1731);
9204 case 1740: return GET_LOOPS (1740);
9205 case 1750: return GET_LOOPS (1750);
9206 case 1760: return GET_LOOPS (1760);
9207 case 1800: return GET_LOOPS (1800);
9208 case 2100: return GET_LOOPS (2100);
9209 case 2400: return GET_LOOPS (2400);
9210 case 2410: return GET_LOOPS (2410);
9211 case 2500: return GET_LOOPS (2500);
9212 case 2600: return GET_LOOPS (2600);
9213 case 2611: return GET_LOOPS (2611);
9214 case 2612: return GET_LOOPS (2612);
9215 case 2711: return GET_LOOPS (2711);
9216 case 2811: return GET_LOOPS (2811);
9217 case 3000: return GET_LOOPS (3000);
9218 case 3100: return GET_LOOPS (3100);
9219 case 3200: return GET_LOOPS (3200);
9220 case 3710: return GET_LOOPS (3710);
9221 case 3711: return GET_LOOPS (3711);
9222 case 3800: return GET_LOOPS (3800);
9223 case 4300: return GET_LOOPS (4300);
9224 case 4400: return GET_LOOPS (4400);
9225 case 4500: return GET_LOOPS (4500);
9226 case 4700: return GET_LOOPS (4700);
9227 case 4800: return GET_LOOPS (4800);
9228 case 4900: return GET_LOOPS (4900);
9229 case 5000: return GET_LOOPS (5000);
9230 case 5100: return GET_LOOPS (5100);
9231 case 5200: return GET_LOOPS (5200);
9232 case 5300: return GET_LOOPS (5300);
9233 case 5400: return GET_LOOPS (5400);
9234 case 5500: return GET_LOOPS (5500);
9235 case 5600: return GET_LOOPS (5600);
9236 case 5700: return GET_LOOPS (5700);
9237 case 5800: return GET_LOOPS (5800);
9238 case 6000: return GET_LOOPS (6000);
9239 case 6100: return GET_LOOPS (6100);
9240 case 6211: return GET_LOOPS (6211);
9241 case 6212: return GET_LOOPS (6212);
9242 case 6213: return GET_LOOPS (6213);
9243 case 6221: return GET_LOOPS (6221);
9244 case 6222: return GET_LOOPS (6222);
9245 case 6223: return GET_LOOPS (6223);
9246 case 6231: return GET_LOOPS (6231);
9247 case 6232: return GET_LOOPS (6232);
9248 case 6233: return GET_LOOPS (6233);
9249 case 6241: return GET_LOOPS (6241);
9250 case 6242: return GET_LOOPS (6242);
9251 case 6243: return GET_LOOPS (6243);
9252 case 6300: return GET_LOOPS (6300);
9253 case 6400: return GET_LOOPS (6400);
9254 case 6500: return GET_LOOPS (6500);
9255 case 6600: return GET_LOOPS (6600);
9256 case 6700: return GET_LOOPS (6700);
9257 case 6800: return GET_LOOPS (6800);
9258 case 6900: return GET_LOOPS (6900);
9259 case 7100: return GET_LOOPS (7100);
9260 case 7200: return GET_LOOPS (7200);
9261 case 7300: return GET_LOOPS (7300);
9262 case 7400: return GET_LOOPS (7400);
9263 case 7500: return GET_LOOPS (7500);
9264 case 7600: return GET_LOOPS (7600);
9265 case 7700: return GET_LOOPS (7700);
9266 case 7800: return GET_LOOPS (7800);
9267 case 7900: return GET_LOOPS (7900);
9268 case 8000: return GET_LOOPS (8000);
9269 case 8100: return GET_LOOPS (8100);
9270 case 8200: return GET_LOOPS (8200);
9271 case 8300: return GET_LOOPS (8300);
9272 case 8400: return GET_LOOPS (8400);
9273 case 8500: return GET_LOOPS (8500);
9274 case 8600: return GET_LOOPS (8600);
9275 case 8700: return GET_LOOPS (8700);
9276 case 8800: return GET_LOOPS (8800);
9277 case 8900: return GET_LOOPS (8900);
9278 case 9000: return GET_LOOPS (9000);
9279 case 9100: return GET_LOOPS (9100);
9280 case 9200: return GET_LOOPS (9200);
9281 case 9300: return GET_LOOPS (9300);
9282 case 9400: return GET_LOOPS (9400);
9283 case 9500: return GET_LOOPS (9500);
9284 case 9600: return GET_LOOPS (9600);
9285 case 9700: return GET_LOOPS (9700);
9286 case 9710: return GET_LOOPS (9710);
9287 case 9720: return GET_LOOPS (9720);
9288 case 9800: return GET_LOOPS (9800);
9289 case 9810: return GET_LOOPS (9810);
9290 case 9820: return GET_LOOPS (9820);
9291 case 9900: return GET_LOOPS (9900);
9292 case 10000: return GET_LOOPS (10000);
9293 case 10100: return GET_LOOPS (10100);
9294 case 10200: return GET_LOOPS (10200);
9295 case 10300: return GET_LOOPS (10300);
9296 case 10400: return GET_LOOPS (10400);
9297 case 10410: return GET_LOOPS (10410);
9298 case 10420: return GET_LOOPS (10420);
9299 case 10500: return GET_LOOPS (10500);
9300 case 10600: return GET_LOOPS (10600);
9301 case 10700: return GET_LOOPS (10700);
9302 case 10800: return GET_LOOPS (10800);
9303 case 10900: return GET_LOOPS (10900);
9304 case 11000: return GET_LOOPS (11000);
9305 case 11100: return GET_LOOPS (11100);
9306 case 11200: return GET_LOOPS (11200);
9307 case 11300: return GET_LOOPS (11300);
9308 case 11400: return GET_LOOPS (11400);
9309 case 11500: return GET_LOOPS (11500);
9310 case 11600: return GET_LOOPS (11600);
9311 case 11700: return GET_LOOPS (11700);
9312 case 11800: return GET_LOOPS (11800);
9313 case 11900: return GET_LOOPS (11900);
9314 case 12000: return GET_LOOPS (12000);
9315 case 12100: return GET_LOOPS (12100);
9316 case 12200: return GET_LOOPS (12200);
9317 case 12300: return GET_LOOPS (12300);
9318 case 12400: return GET_LOOPS (12400);
9319 case 12500: return GET_LOOPS (12500);
9320 case 12600: return GET_LOOPS (12600);
9321 case 12700: return GET_LOOPS (12700);
9322 case 12800: return GET_LOOPS (12800);
9323 case 12900: return GET_LOOPS (12900);
9324 case 13000: return GET_LOOPS (13000);
9334 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9338 if (salt_len
> sizeof(tmp
))
9343 memset (tmp
, 0, sizeof (tmp
));
9344 memcpy (tmp
, in
, salt_len
);
9346 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9348 if ((salt_len
% 2) == 0)
9350 uint new_salt_len
= salt_len
/ 2;
9352 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9354 char p0
= tmp
[j
+ 0];
9355 char p1
= tmp
[j
+ 1];
9357 tmp
[i
] = hex_convert (p1
) << 0;
9358 tmp
[i
] |= hex_convert (p0
) << 4;
9361 salt_len
= new_salt_len
;
9368 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9370 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9373 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9375 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9379 uint
*tmp_uint
= (uint
*) tmp
;
9381 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9382 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9383 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9384 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9385 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9386 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9387 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9388 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9389 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9390 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9392 salt_len
= salt_len
* 2;
9400 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9402 lowercase (tmp
, salt_len
);
9405 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9407 uppercase (tmp
, salt_len
);
9410 uint len
= salt_len
;
9412 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9417 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9422 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9424 uint
*tmp_uint
= (uint
*) tmp
;
9430 for (uint i
= 0; i
< max
; i
++)
9432 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9435 // Important: we may need to increase the length of memcpy since
9436 // we don't want to "loose" some swapped bytes (could happen if
9437 // they do not perfectly fit in the 4-byte blocks)
9438 // Memcpy does always copy the bytes in the BE order, but since
9439 // we swapped them, some important bytes could be in positions
9440 // we normally skip with the original len
9442 if (len
% 4) len
+= 4 - (len
% 4);
9445 memcpy (out
, tmp
, len
);
9450 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9452 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9454 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9456 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9458 salt_t
*salt
= hash_buf
->salt
;
9460 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9462 char *iter_pos
= input_buf
+ 4;
9464 salt
->salt_iter
= 1 << atoi (iter_pos
);
9466 char *salt_pos
= strchr (iter_pos
, '$');
9468 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9474 salt
->salt_len
= salt_len
;
9478 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9480 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9482 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9484 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9486 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9487 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9488 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9489 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9491 char *hash_pos
= salt_pos
+ 22;
9493 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9495 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9497 memcpy (digest
, tmp_buf
, 24);
9499 digest
[0] = byte_swap_32 (digest
[0]);
9500 digest
[1] = byte_swap_32 (digest
[1]);
9501 digest
[2] = byte_swap_32 (digest
[2]);
9502 digest
[3] = byte_swap_32 (digest
[3]);
9503 digest
[4] = byte_swap_32 (digest
[4]);
9504 digest
[5] = byte_swap_32 (digest
[5]);
9506 digest
[5] &= ~0xff; // its just 23 not 24 !
9511 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9513 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9515 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9519 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9521 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9523 memcpy (digest
, tmp_buf
, 32);
9525 digest
[0] = byte_swap_32 (digest
[0]);
9526 digest
[1] = byte_swap_32 (digest
[1]);
9527 digest
[2] = byte_swap_32 (digest
[2]);
9528 digest
[3] = byte_swap_32 (digest
[3]);
9529 digest
[4] = byte_swap_32 (digest
[4]);
9530 digest
[5] = byte_swap_32 (digest
[5]);
9531 digest
[6] = byte_swap_32 (digest
[6]);
9532 digest
[7] = byte_swap_32 (digest
[7]);
9534 digest
[0] -= SHA256M_A
;
9535 digest
[1] -= SHA256M_B
;
9536 digest
[2] -= SHA256M_C
;
9537 digest
[3] -= SHA256M_D
;
9538 digest
[4] -= SHA256M_E
;
9539 digest
[5] -= SHA256M_F
;
9540 digest
[6] -= SHA256M_G
;
9541 digest
[7] -= SHA256M_H
;
9546 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9548 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9550 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9552 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9553 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9555 digest
[0] = byte_swap_32 (digest
[0]);
9556 digest
[1] = byte_swap_32 (digest
[1]);
9560 IP (digest
[0], digest
[1], tt
);
9562 digest
[0] = digest
[0];
9563 digest
[1] = digest
[1];
9570 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9572 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9574 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9576 salt_t
*salt
= hash_buf
->salt
;
9578 char *hash_pos
= input_buf
+ 8;
9580 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9581 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9582 digest
[2] = hex_to_uint (&hash_pos
[16]);
9583 digest
[3] = hex_to_uint (&hash_pos
[24]);
9584 digest
[4] = hex_to_uint (&hash_pos
[32]);
9586 digest
[0] -= SHA1M_A
;
9587 digest
[1] -= SHA1M_B
;
9588 digest
[2] -= SHA1M_C
;
9589 digest
[3] -= SHA1M_D
;
9590 digest
[4] -= SHA1M_E
;
9594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9596 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9598 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9600 salt
->salt_len
= salt_len
;
9605 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9607 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9609 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9611 salt_t
*salt
= hash_buf
->salt
;
9613 char *hash_pos
= input_buf
+ 8;
9615 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9616 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9617 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9618 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9619 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9620 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9621 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9622 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9624 digest
[0] -= SHA512M_A
;
9625 digest
[1] -= SHA512M_B
;
9626 digest
[2] -= SHA512M_C
;
9627 digest
[3] -= SHA512M_D
;
9628 digest
[4] -= SHA512M_E
;
9629 digest
[5] -= SHA512M_F
;
9630 digest
[6] -= SHA512M_G
;
9631 digest
[7] -= SHA512M_H
;
9635 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9637 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9639 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9641 salt
->salt_len
= salt_len
;
9646 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9648 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9650 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9654 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9657 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9659 salt_t
*salt
= hash_buf
->salt
;
9661 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9662 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9663 digest
[2] = hex_to_uint (&input_buf
[16]);
9664 digest
[3] = hex_to_uint (&input_buf
[24]);
9666 digest
[0] = byte_swap_32 (digest
[0]);
9667 digest
[1] = byte_swap_32 (digest
[1]);
9668 digest
[2] = byte_swap_32 (digest
[2]);
9669 digest
[3] = byte_swap_32 (digest
[3]);
9671 digest
[0] -= MD5M_A
;
9672 digest
[1] -= MD5M_B
;
9673 digest
[2] -= MD5M_C
;
9674 digest
[3] -= MD5M_D
;
9676 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9678 uint salt_len
= input_len
- 32 - 1;
9680 char *salt_buf
= input_buf
+ 32 + 1;
9682 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9684 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9686 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9688 salt
->salt_len
= salt_len
;
9693 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9695 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9697 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9701 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9706 char clean_input_buf
[32];
9708 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9709 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9711 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9715 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9721 clean_input_buf
[k
] = input_buf
[i
];
9729 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9731 salt_t
*salt
= hash_buf
->salt
;
9733 char a
, b
, c
, d
, e
, f
;
9735 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9736 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9737 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9738 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9739 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9740 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9742 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9743 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9745 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9746 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9747 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9748 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9749 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9750 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9752 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9753 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9755 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9756 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9757 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9758 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9759 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9760 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9762 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9763 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9765 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9766 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9767 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9768 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9769 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9770 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9772 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9773 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9775 digest
[0] = byte_swap_32 (digest
[0]);
9776 digest
[1] = byte_swap_32 (digest
[1]);
9777 digest
[2] = byte_swap_32 (digest
[2]);
9778 digest
[3] = byte_swap_32 (digest
[3]);
9780 digest
[0] -= MD5M_A
;
9781 digest
[1] -= MD5M_B
;
9782 digest
[2] -= MD5M_C
;
9783 digest
[3] -= MD5M_D
;
9785 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9787 uint salt_len
= input_len
- 30 - 1;
9789 char *salt_buf
= input_buf
+ 30 + 1;
9791 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9793 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9795 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9796 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9798 salt
->salt_len
= salt_len
;
9800 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9802 salt
->salt_len
+= 22;
9807 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9809 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9811 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9815 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9818 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9820 salt_t
*salt
= hash_buf
->salt
;
9822 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9823 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9824 digest
[2] = hex_to_uint (&input_buf
[16]);
9825 digest
[3] = hex_to_uint (&input_buf
[24]);
9826 digest
[4] = hex_to_uint (&input_buf
[32]);
9828 digest
[0] -= SHA1M_A
;
9829 digest
[1] -= SHA1M_B
;
9830 digest
[2] -= SHA1M_C
;
9831 digest
[3] -= SHA1M_D
;
9832 digest
[4] -= SHA1M_E
;
9834 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9836 uint salt_len
= input_len
- 40 - 1;
9838 char *salt_buf
= input_buf
+ 40 + 1;
9840 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9842 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9844 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9846 salt
->salt_len
= salt_len
;
9851 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9853 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9855 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9859 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9862 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9864 char *iter_pos
= input_buf
+ 6;
9866 salt_t
*salt
= hash_buf
->salt
;
9868 salt
->salt_iter
= atoi (iter_pos
) - 1;
9870 char *salt_pos
= strchr (iter_pos
, '#');
9872 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9876 char *digest_pos
= strchr (salt_pos
, '#');
9878 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9882 uint salt_len
= digest_pos
- salt_pos
- 1;
9884 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9886 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9887 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9888 digest
[2] = hex_to_uint (&digest_pos
[16]);
9889 digest
[3] = hex_to_uint (&digest_pos
[24]);
9891 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9893 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9895 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9897 salt
->salt_len
= salt_len
;
9902 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9904 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9906 salt_t
*salt
= hash_buf
->salt
;
9908 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9912 memcpy (&in
, input_buf
, input_len
);
9914 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9916 memcpy (digest
, in
.keymic
, 16);
9919 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9920 The phrase "Pairwise key expansion"
9921 Access Point Address (Referred to as Authenticator Address AA)
9922 Supplicant Address (referred to as Supplicant Address SA)
9923 Access Point Nonce (referred to as Authenticator Anonce)
9924 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9927 uint salt_len
= strlen (in
.essid
);
9929 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9931 salt
->salt_len
= salt_len
;
9933 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9935 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9937 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9939 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9941 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9942 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9946 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9947 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9950 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9952 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9953 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9957 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9958 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9961 for (int i
= 0; i
< 25; i
++)
9963 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9966 wpa
->keyver
= in
.keyver
;
9968 if (wpa
->keyver
> 255)
9970 log_info ("ATTENTION!");
9971 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9972 log_info (" This could be due to a recent aircrack-ng bug.");
9973 log_info (" The key version was automatically reset to a reasonable value.");
9976 wpa
->keyver
&= 0xff;
9979 wpa
->eapol_size
= in
.eapol_size
;
9981 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9983 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9985 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9987 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9989 if (wpa
->keyver
== 1)
9995 digest
[0] = byte_swap_32 (digest
[0]);
9996 digest
[1] = byte_swap_32 (digest
[1]);
9997 digest
[2] = byte_swap_32 (digest
[2]);
9998 digest
[3] = byte_swap_32 (digest
[3]);
10000 for (int i
= 0; i
< 64; i
++)
10002 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10006 salt
->salt_buf
[10] = digest
[1];
10007 salt
->salt_buf
[11] = digest
[2];
10009 return (PARSER_OK
);
10012 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10014 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10016 salt_t
*salt
= hash_buf
->salt
;
10018 if (input_len
== 0)
10020 log_error ("Password Safe v2 container not specified");
10025 FILE *fp
= fopen (input_buf
, "rb");
10029 log_error ("%s: %s", input_buf
, strerror (errno
));
10036 uint32_t random
[2];
10038 uint32_t salt
[5]; // unused, but makes better valid check
10039 uint32_t iv
[2]; // unused, but makes better valid check
10045 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10049 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10051 salt
->salt_buf
[0] = buf
.random
[0];
10052 salt
->salt_buf
[1] = buf
.random
[1];
10054 salt
->salt_len
= 8;
10055 salt
->salt_iter
= 1000;
10057 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10058 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10059 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10060 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10061 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10063 return (PARSER_OK
);
10066 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10068 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10070 salt_t
*salt
= hash_buf
->salt
;
10072 if (input_len
== 0)
10074 log_error (".psafe3 not specified");
10079 FILE *fp
= fopen (input_buf
, "rb");
10083 log_error ("%s: %s", input_buf
, strerror (errno
));
10090 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10094 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10096 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10098 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10100 salt
->salt_iter
= in
.iterations
+ 1;
10102 salt
->salt_buf
[0] = in
.salt_buf
[0];
10103 salt
->salt_buf
[1] = in
.salt_buf
[1];
10104 salt
->salt_buf
[2] = in
.salt_buf
[2];
10105 salt
->salt_buf
[3] = in
.salt_buf
[3];
10106 salt
->salt_buf
[4] = in
.salt_buf
[4];
10107 salt
->salt_buf
[5] = in
.salt_buf
[5];
10108 salt
->salt_buf
[6] = in
.salt_buf
[6];
10109 salt
->salt_buf
[7] = in
.salt_buf
[7];
10111 salt
->salt_len
= 32;
10113 digest
[0] = in
.hash_buf
[0];
10114 digest
[1] = in
.hash_buf
[1];
10115 digest
[2] = in
.hash_buf
[2];
10116 digest
[3] = in
.hash_buf
[3];
10117 digest
[4] = in
.hash_buf
[4];
10118 digest
[5] = in
.hash_buf
[5];
10119 digest
[6] = in
.hash_buf
[6];
10120 digest
[7] = in
.hash_buf
[7];
10122 digest
[0] = byte_swap_32 (digest
[0]);
10123 digest
[1] = byte_swap_32 (digest
[1]);
10124 digest
[2] = byte_swap_32 (digest
[2]);
10125 digest
[3] = byte_swap_32 (digest
[3]);
10126 digest
[4] = byte_swap_32 (digest
[4]);
10127 digest
[5] = byte_swap_32 (digest
[5]);
10128 digest
[6] = byte_swap_32 (digest
[6]);
10129 digest
[7] = byte_swap_32 (digest
[7]);
10131 return (PARSER_OK
);
10134 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10136 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10138 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10140 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10142 salt_t
*salt
= hash_buf
->salt
;
10144 char *iter_pos
= input_buf
+ 3;
10146 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10148 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10150 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10152 salt
->salt_iter
= salt_iter
;
10154 char *salt_pos
= iter_pos
+ 1;
10158 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10160 salt
->salt_len
= salt_len
;
10162 char *hash_pos
= salt_pos
+ salt_len
;
10164 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10166 return (PARSER_OK
);
10169 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10171 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10173 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10175 salt_t
*salt
= hash_buf
->salt
;
10177 char *salt_pos
= input_buf
+ 3;
10179 uint iterations_len
= 0;
10181 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10185 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10187 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10188 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10192 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10196 iterations_len
+= 8;
10200 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10203 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10205 char *hash_pos
= strchr (salt_pos
, '$');
10207 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10209 uint salt_len
= hash_pos
- salt_pos
;
10211 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10213 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10215 salt
->salt_len
= salt_len
;
10219 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10221 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10223 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10225 return (PARSER_OK
);
10228 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10230 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10232 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10234 salt_t
*salt
= hash_buf
->salt
;
10236 char *salt_pos
= input_buf
+ 6;
10238 uint iterations_len
= 0;
10240 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10244 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10246 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10247 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10251 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10255 iterations_len
+= 8;
10259 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10262 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10264 char *hash_pos
= strchr (salt_pos
, '$');
10266 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10268 uint salt_len
= hash_pos
- salt_pos
;
10270 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10272 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10274 salt
->salt_len
= salt_len
;
10278 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10280 return (PARSER_OK
);
10283 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10285 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10287 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10289 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10291 salt_t
*salt
= hash_buf
->salt
;
10293 char *salt_pos
= input_buf
+ 14;
10295 char *hash_pos
= strchr (salt_pos
, '*');
10297 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10301 uint salt_len
= hash_pos
- salt_pos
- 1;
10303 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10305 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10307 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10309 salt
->salt_len
= salt_len
;
10311 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10313 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10315 memcpy (digest
, tmp_buf
, 20);
10317 digest
[0] = byte_swap_32 (digest
[0]);
10318 digest
[1] = byte_swap_32 (digest
[1]);
10319 digest
[2] = byte_swap_32 (digest
[2]);
10320 digest
[3] = byte_swap_32 (digest
[3]);
10321 digest
[4] = byte_swap_32 (digest
[4]);
10323 digest
[0] -= SHA1M_A
;
10324 digest
[1] -= SHA1M_B
;
10325 digest
[2] -= SHA1M_C
;
10326 digest
[3] -= SHA1M_D
;
10327 digest
[4] -= SHA1M_E
;
10329 return (PARSER_OK
);
10332 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10334 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10336 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10338 if (c12
& 3) return (PARSER_HASH_VALUE
);
10340 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10342 salt_t
*salt
= hash_buf
->salt
;
10344 // for ascii_digest
10345 salt
->salt_sign
[0] = input_buf
[0];
10346 salt
->salt_sign
[1] = input_buf
[1];
10348 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10349 | itoa64_to_int (input_buf
[1]) << 6;
10351 salt
->salt_len
= 2;
10355 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10357 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10359 memcpy (digest
, tmp_buf
, 8);
10363 IP (digest
[0], digest
[1], tt
);
10368 return (PARSER_OK
);
10371 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10373 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10375 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10377 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10378 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10379 digest
[2] = hex_to_uint (&input_buf
[16]);
10380 digest
[3] = hex_to_uint (&input_buf
[24]);
10382 digest
[0] = byte_swap_32 (digest
[0]);
10383 digest
[1] = byte_swap_32 (digest
[1]);
10384 digest
[2] = byte_swap_32 (digest
[2]);
10385 digest
[3] = byte_swap_32 (digest
[3]);
10387 digest
[0] -= MD4M_A
;
10388 digest
[1] -= MD4M_B
;
10389 digest
[2] -= MD4M_C
;
10390 digest
[3] -= MD4M_D
;
10392 return (PARSER_OK
);
10395 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10397 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10399 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10403 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10406 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10408 salt_t
*salt
= hash_buf
->salt
;
10410 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10411 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10412 digest
[2] = hex_to_uint (&input_buf
[16]);
10413 digest
[3] = hex_to_uint (&input_buf
[24]);
10415 digest
[0] = byte_swap_32 (digest
[0]);
10416 digest
[1] = byte_swap_32 (digest
[1]);
10417 digest
[2] = byte_swap_32 (digest
[2]);
10418 digest
[3] = byte_swap_32 (digest
[3]);
10420 digest
[0] -= MD4M_A
;
10421 digest
[1] -= MD4M_B
;
10422 digest
[2] -= MD4M_C
;
10423 digest
[3] -= MD4M_D
;
10425 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10427 uint salt_len
= input_len
- 32 - 1;
10429 char *salt_buf
= input_buf
+ 32 + 1;
10431 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10433 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10435 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10437 salt
->salt_len
= salt_len
;
10439 return (PARSER_OK
);
10442 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10444 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10446 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10448 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10449 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10450 digest
[2] = hex_to_uint (&input_buf
[16]);
10451 digest
[3] = hex_to_uint (&input_buf
[24]);
10453 digest
[0] = byte_swap_32 (digest
[0]);
10454 digest
[1] = byte_swap_32 (digest
[1]);
10455 digest
[2] = byte_swap_32 (digest
[2]);
10456 digest
[3] = byte_swap_32 (digest
[3]);
10458 digest
[0] -= MD5M_A
;
10459 digest
[1] -= MD5M_B
;
10460 digest
[2] -= MD5M_C
;
10461 digest
[3] -= MD5M_D
;
10463 return (PARSER_OK
);
10466 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10468 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10470 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10472 digest
[0] = hex_to_uint (&input_buf
[0]);
10473 digest
[1] = hex_to_uint (&input_buf
[8]);
10477 digest
[0] = byte_swap_32 (digest
[0]);
10478 digest
[1] = byte_swap_32 (digest
[1]);
10480 return (PARSER_OK
);
10483 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10485 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10487 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10491 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10494 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10496 salt_t
*salt
= hash_buf
->salt
;
10498 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10499 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10500 digest
[2] = hex_to_uint (&input_buf
[16]);
10501 digest
[3] = hex_to_uint (&input_buf
[24]);
10503 digest
[0] = byte_swap_32 (digest
[0]);
10504 digest
[1] = byte_swap_32 (digest
[1]);
10505 digest
[2] = byte_swap_32 (digest
[2]);
10506 digest
[3] = byte_swap_32 (digest
[3]);
10508 digest
[0] -= MD5M_A
;
10509 digest
[1] -= MD5M_B
;
10510 digest
[2] -= MD5M_C
;
10511 digest
[3] -= MD5M_D
;
10513 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10515 uint salt_len
= input_len
- 32 - 1;
10517 char *salt_buf
= input_buf
+ 32 + 1;
10519 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10521 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10523 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10525 salt
->salt_len
= salt_len
;
10527 return (PARSER_OK
);
10530 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10532 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10534 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10536 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10537 | itoa64_to_int (input_buf
[ 1]) << 6
10538 | itoa64_to_int (input_buf
[ 2]) << 12
10539 | itoa64_to_int (input_buf
[ 3]) << 18;
10540 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10541 | itoa64_to_int (input_buf
[ 5]) << 6
10542 | itoa64_to_int (input_buf
[ 6]) << 12
10543 | itoa64_to_int (input_buf
[ 7]) << 18;
10544 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10545 | itoa64_to_int (input_buf
[ 9]) << 6
10546 | itoa64_to_int (input_buf
[10]) << 12
10547 | itoa64_to_int (input_buf
[11]) << 18;
10548 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10549 | itoa64_to_int (input_buf
[13]) << 6
10550 | itoa64_to_int (input_buf
[14]) << 12
10551 | itoa64_to_int (input_buf
[15]) << 18;
10553 digest
[0] -= MD5M_A
;
10554 digest
[1] -= MD5M_B
;
10555 digest
[2] -= MD5M_C
;
10556 digest
[3] -= MD5M_D
;
10558 digest
[0] &= 0x00ffffff;
10559 digest
[1] &= 0x00ffffff;
10560 digest
[2] &= 0x00ffffff;
10561 digest
[3] &= 0x00ffffff;
10563 return (PARSER_OK
);
10566 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10568 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10570 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10574 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10577 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10579 salt_t
*salt
= hash_buf
->salt
;
10581 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10582 | itoa64_to_int (input_buf
[ 1]) << 6
10583 | itoa64_to_int (input_buf
[ 2]) << 12
10584 | itoa64_to_int (input_buf
[ 3]) << 18;
10585 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10586 | itoa64_to_int (input_buf
[ 5]) << 6
10587 | itoa64_to_int (input_buf
[ 6]) << 12
10588 | itoa64_to_int (input_buf
[ 7]) << 18;
10589 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10590 | itoa64_to_int (input_buf
[ 9]) << 6
10591 | itoa64_to_int (input_buf
[10]) << 12
10592 | itoa64_to_int (input_buf
[11]) << 18;
10593 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10594 | itoa64_to_int (input_buf
[13]) << 6
10595 | itoa64_to_int (input_buf
[14]) << 12
10596 | itoa64_to_int (input_buf
[15]) << 18;
10598 digest
[0] -= MD5M_A
;
10599 digest
[1] -= MD5M_B
;
10600 digest
[2] -= MD5M_C
;
10601 digest
[3] -= MD5M_D
;
10603 digest
[0] &= 0x00ffffff;
10604 digest
[1] &= 0x00ffffff;
10605 digest
[2] &= 0x00ffffff;
10606 digest
[3] &= 0x00ffffff;
10608 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10610 uint salt_len
= input_len
- 16 - 1;
10612 char *salt_buf
= input_buf
+ 16 + 1;
10614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10616 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10620 salt
->salt_len
= salt_len
;
10622 return (PARSER_OK
);
10625 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10627 key
[0] = (nthash
[0] >> 0);
10628 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10629 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10630 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10631 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10632 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10633 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10634 key
[7] = (nthash
[6] << 1);
10646 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10648 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10650 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10652 salt_t
*salt
= hash_buf
->salt
;
10654 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10660 char *user_pos
= input_buf
;
10662 char *unused_pos
= strchr (user_pos
, ':');
10664 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10666 uint user_len
= unused_pos
- user_pos
;
10668 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10672 char *domain_pos
= strchr (unused_pos
, ':');
10674 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10676 uint unused_len
= domain_pos
- unused_pos
;
10678 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10682 char *srvchall_pos
= strchr (domain_pos
, ':');
10684 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10686 uint domain_len
= srvchall_pos
- domain_pos
;
10688 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10692 char *hash_pos
= strchr (srvchall_pos
, ':');
10694 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10696 uint srvchall_len
= hash_pos
- srvchall_pos
;
10698 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10702 char *clichall_pos
= strchr (hash_pos
, ':');
10704 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10706 uint hash_len
= clichall_pos
- hash_pos
;
10708 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10712 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10714 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10717 * store some data for later use
10720 netntlm
->user_len
= user_len
* 2;
10721 netntlm
->domain_len
= domain_len
* 2;
10722 netntlm
->srvchall_len
= srvchall_len
/ 2;
10723 netntlm
->clichall_len
= clichall_len
/ 2;
10725 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10726 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10729 * handle username and domainname
10732 for (uint i
= 0; i
< user_len
; i
++)
10734 *userdomain_ptr
++ = user_pos
[i
];
10735 *userdomain_ptr
++ = 0;
10738 for (uint i
= 0; i
< domain_len
; i
++)
10740 *userdomain_ptr
++ = domain_pos
[i
];
10741 *userdomain_ptr
++ = 0;
10745 * handle server challenge encoding
10748 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10750 const char p0
= srvchall_pos
[i
+ 0];
10751 const char p1
= srvchall_pos
[i
+ 1];
10753 *chall_ptr
++ = hex_convert (p1
) << 0
10754 | hex_convert (p0
) << 4;
10758 * handle client challenge encoding
10761 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10763 const char p0
= clichall_pos
[i
+ 0];
10764 const char p1
= clichall_pos
[i
+ 1];
10766 *chall_ptr
++ = hex_convert (p1
) << 0
10767 | hex_convert (p0
) << 4;
10774 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10776 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10778 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10780 salt
->salt_len
= salt_len
;
10782 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10783 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10784 digest
[2] = hex_to_uint (&hash_pos
[16]);
10785 digest
[3] = hex_to_uint (&hash_pos
[24]);
10787 digest
[0] = byte_swap_32 (digest
[0]);
10788 digest
[1] = byte_swap_32 (digest
[1]);
10789 digest
[2] = byte_swap_32 (digest
[2]);
10790 digest
[3] = byte_swap_32 (digest
[3]);
10792 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10794 uint digest_tmp
[2];
10796 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10797 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10799 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10800 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10802 /* special case 2: ESS */
10804 if (srvchall_len
== 48)
10806 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10810 w
[ 0] = netntlm
->chall_buf
[6];
10811 w
[ 1] = netntlm
->chall_buf
[7];
10812 w
[ 2] = netntlm
->chall_buf
[0];
10813 w
[ 3] = netntlm
->chall_buf
[1];
10836 salt
->salt_buf
[0] = dgst
[0];
10837 salt
->salt_buf
[1] = dgst
[1];
10841 /* precompute netntlmv1 exploit start */
10843 for (uint i
= 0; i
< 0x10000; i
++)
10845 uint key_md4
[2] = { i
, 0 };
10846 uint key_des
[2] = { 0, 0 };
10848 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10853 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10855 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10857 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10859 if (data3
[0] != digest_tmp
[0]) continue;
10860 if (data3
[1] != digest_tmp
[1]) continue;
10862 salt
->salt_buf
[2] = i
;
10864 salt
->salt_len
= 24;
10869 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10870 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10872 /* precompute netntlmv1 exploit stop */
10876 IP (digest
[0], digest
[1], tt
);
10877 IP (digest
[2], digest
[3], tt
);
10879 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10880 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10881 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10882 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10884 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10886 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10887 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10889 return (PARSER_OK
);
10892 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10894 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10896 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10898 salt_t
*salt
= hash_buf
->salt
;
10900 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10906 char *user_pos
= input_buf
;
10908 char *unused_pos
= strchr (user_pos
, ':');
10910 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10912 uint user_len
= unused_pos
- user_pos
;
10914 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10918 char *domain_pos
= strchr (unused_pos
, ':');
10920 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10922 uint unused_len
= domain_pos
- unused_pos
;
10924 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10928 char *srvchall_pos
= strchr (domain_pos
, ':');
10930 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10932 uint domain_len
= srvchall_pos
- domain_pos
;
10934 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10938 char *hash_pos
= strchr (srvchall_pos
, ':');
10940 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10942 uint srvchall_len
= hash_pos
- srvchall_pos
;
10944 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10948 char *clichall_pos
= strchr (hash_pos
, ':');
10950 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10952 uint hash_len
= clichall_pos
- hash_pos
;
10954 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10958 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10960 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10962 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10965 * store some data for later use
10968 netntlm
->user_len
= user_len
* 2;
10969 netntlm
->domain_len
= domain_len
* 2;
10970 netntlm
->srvchall_len
= srvchall_len
/ 2;
10971 netntlm
->clichall_len
= clichall_len
/ 2;
10973 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10974 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10977 * handle username and domainname
10980 for (uint i
= 0; i
< user_len
; i
++)
10982 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10983 *userdomain_ptr
++ = 0;
10986 for (uint i
= 0; i
< domain_len
; i
++)
10988 *userdomain_ptr
++ = domain_pos
[i
];
10989 *userdomain_ptr
++ = 0;
10992 *userdomain_ptr
++ = 0x80;
10995 * handle server challenge encoding
10998 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11000 const char p0
= srvchall_pos
[i
+ 0];
11001 const char p1
= srvchall_pos
[i
+ 1];
11003 *chall_ptr
++ = hex_convert (p1
) << 0
11004 | hex_convert (p0
) << 4;
11008 * handle client challenge encoding
11011 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11013 const char p0
= clichall_pos
[i
+ 0];
11014 const char p1
= clichall_pos
[i
+ 1];
11016 *chall_ptr
++ = hex_convert (p1
) << 0
11017 | hex_convert (p0
) << 4;
11020 *chall_ptr
++ = 0x80;
11023 * handle hash itself
11026 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11027 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11028 digest
[2] = hex_to_uint (&hash_pos
[16]);
11029 digest
[3] = hex_to_uint (&hash_pos
[24]);
11031 digest
[0] = byte_swap_32 (digest
[0]);
11032 digest
[1] = byte_swap_32 (digest
[1]);
11033 digest
[2] = byte_swap_32 (digest
[2]);
11034 digest
[3] = byte_swap_32 (digest
[3]);
11037 * reuse challange data as salt_buf, its the buffer that is most likely unique
11040 salt
->salt_buf
[0] = 0;
11041 salt
->salt_buf
[1] = 0;
11042 salt
->salt_buf
[2] = 0;
11043 salt
->salt_buf
[3] = 0;
11044 salt
->salt_buf
[4] = 0;
11045 salt
->salt_buf
[5] = 0;
11046 salt
->salt_buf
[6] = 0;
11047 salt
->salt_buf
[7] = 0;
11051 uptr
= (uint
*) netntlm
->userdomain_buf
;
11053 for (uint i
= 0; i
< 16; i
+= 16)
11055 md5_64 (uptr
, salt
->salt_buf
);
11058 uptr
= (uint
*) netntlm
->chall_buf
;
11060 for (uint i
= 0; i
< 256; i
+= 16)
11062 md5_64 (uptr
, salt
->salt_buf
);
11065 salt
->salt_len
= 16;
11067 return (PARSER_OK
);
11070 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11072 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11074 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11078 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11081 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11083 salt_t
*salt
= hash_buf
->salt
;
11085 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11086 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11087 digest
[2] = hex_to_uint (&input_buf
[16]);
11088 digest
[3] = hex_to_uint (&input_buf
[24]);
11090 digest
[0] = byte_swap_32 (digest
[0]);
11091 digest
[1] = byte_swap_32 (digest
[1]);
11092 digest
[2] = byte_swap_32 (digest
[2]);
11093 digest
[3] = byte_swap_32 (digest
[3]);
11095 digest
[0] -= MD5M_A
;
11096 digest
[1] -= MD5M_B
;
11097 digest
[2] -= MD5M_C
;
11098 digest
[3] -= MD5M_D
;
11100 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11102 uint salt_len
= input_len
- 32 - 1;
11104 char *salt_buf
= input_buf
+ 32 + 1;
11106 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11108 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11110 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11112 salt
->salt_len
= salt_len
;
11114 return (PARSER_OK
);
11117 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11119 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11121 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11125 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11128 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11130 salt_t
*salt
= hash_buf
->salt
;
11132 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11133 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11134 digest
[2] = hex_to_uint (&input_buf
[16]);
11135 digest
[3] = hex_to_uint (&input_buf
[24]);
11137 digest
[0] = byte_swap_32 (digest
[0]);
11138 digest
[1] = byte_swap_32 (digest
[1]);
11139 digest
[2] = byte_swap_32 (digest
[2]);
11140 digest
[3] = byte_swap_32 (digest
[3]);
11142 digest
[0] -= MD5M_A
;
11143 digest
[1] -= MD5M_B
;
11144 digest
[2] -= MD5M_C
;
11145 digest
[3] -= MD5M_D
;
11147 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11149 uint salt_len
= input_len
- 32 - 1;
11151 char *salt_buf
= input_buf
+ 32 + 1;
11153 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11155 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11157 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11159 salt
->salt_len
= salt_len
;
11161 return (PARSER_OK
);
11164 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11166 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11168 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11170 salt_t
*salt
= hash_buf
->salt
;
11172 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11173 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11174 digest
[2] = hex_to_uint (&input_buf
[16]);
11175 digest
[3] = hex_to_uint (&input_buf
[24]);
11177 digest
[0] = byte_swap_32 (digest
[0]);
11178 digest
[1] = byte_swap_32 (digest
[1]);
11179 digest
[2] = byte_swap_32 (digest
[2]);
11180 digest
[3] = byte_swap_32 (digest
[3]);
11182 digest
[0] -= MD5M_A
;
11183 digest
[1] -= MD5M_B
;
11184 digest
[2] -= MD5M_C
;
11185 digest
[3] -= MD5M_D
;
11188 * This is a virtual salt. While the algorithm is basically not salted
11189 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11190 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11193 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11195 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11199 salt
->salt_len
= salt_len
;
11201 return (PARSER_OK
);
11204 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11206 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11208 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11212 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11215 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11217 salt_t
*salt
= hash_buf
->salt
;
11219 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11220 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11221 digest
[2] = hex_to_uint (&input_buf
[16]);
11222 digest
[3] = hex_to_uint (&input_buf
[24]);
11224 digest
[0] = byte_swap_32 (digest
[0]);
11225 digest
[1] = byte_swap_32 (digest
[1]);
11226 digest
[2] = byte_swap_32 (digest
[2]);
11227 digest
[3] = byte_swap_32 (digest
[3]);
11229 digest
[0] -= MD5M_A
;
11230 digest
[1] -= MD5M_B
;
11231 digest
[2] -= MD5M_C
;
11232 digest
[3] -= MD5M_D
;
11234 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11236 uint salt_len
= input_len
- 32 - 1;
11238 char *salt_buf
= input_buf
+ 32 + 1;
11240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11246 salt
->salt_len
= salt_len
;
11248 return (PARSER_OK
);
11251 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11253 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11255 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11259 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11262 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11264 salt_t
*salt
= hash_buf
->salt
;
11266 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11267 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11268 digest
[2] = hex_to_uint (&input_buf
[16]);
11269 digest
[3] = hex_to_uint (&input_buf
[24]);
11271 digest
[0] = byte_swap_32 (digest
[0]);
11272 digest
[1] = byte_swap_32 (digest
[1]);
11273 digest
[2] = byte_swap_32 (digest
[2]);
11274 digest
[3] = byte_swap_32 (digest
[3]);
11276 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11278 uint salt_len
= input_len
- 32 - 1;
11280 char *salt_buf
= input_buf
+ 32 + 1;
11282 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11284 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11286 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11288 salt
->salt_len
= salt_len
;
11290 return (PARSER_OK
);
11293 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11295 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11297 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11301 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11304 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11306 salt_t
*salt
= hash_buf
->salt
;
11308 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11309 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11310 digest
[2] = hex_to_uint (&input_buf
[16]);
11311 digest
[3] = hex_to_uint (&input_buf
[24]);
11313 digest
[0] = byte_swap_32 (digest
[0]);
11314 digest
[1] = byte_swap_32 (digest
[1]);
11315 digest
[2] = byte_swap_32 (digest
[2]);
11316 digest
[3] = byte_swap_32 (digest
[3]);
11318 digest
[0] -= MD4M_A
;
11319 digest
[1] -= MD4M_B
;
11320 digest
[2] -= MD4M_C
;
11321 digest
[3] -= MD4M_D
;
11323 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11325 uint salt_len
= input_len
- 32 - 1;
11327 char *salt_buf
= input_buf
+ 32 + 1;
11329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11335 salt
->salt_len
= salt_len
;
11337 return (PARSER_OK
);
11340 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11342 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11344 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11348 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11351 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11353 salt_t
*salt
= hash_buf
->salt
;
11355 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11356 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11357 digest
[2] = hex_to_uint (&input_buf
[16]);
11358 digest
[3] = hex_to_uint (&input_buf
[24]);
11360 digest
[0] = byte_swap_32 (digest
[0]);
11361 digest
[1] = byte_swap_32 (digest
[1]);
11362 digest
[2] = byte_swap_32 (digest
[2]);
11363 digest
[3] = byte_swap_32 (digest
[3]);
11365 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11367 uint salt_len
= input_len
- 32 - 1;
11369 char *salt_buf
= input_buf
+ 32 + 1;
11371 uint salt_pc_block
[16];
11373 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11375 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11377 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11379 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11381 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11383 salt_pc_block
[14] = salt_len
* 8;
11385 uint salt_pc_digest
[4];
11387 salt_pc_digest
[0] = MAGIC_A
;
11388 salt_pc_digest
[1] = MAGIC_B
;
11389 salt_pc_digest
[2] = MAGIC_C
;
11390 salt_pc_digest
[3] = MAGIC_D
;
11392 md5_64 (salt_pc_block
, salt_pc_digest
);
11394 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11395 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11396 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11397 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11399 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11401 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11403 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11405 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11406 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11407 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11408 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11410 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11412 return (PARSER_OK
);
11415 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11417 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11419 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11421 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11422 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11423 digest
[2] = hex_to_uint (&input_buf
[16]);
11424 digest
[3] = hex_to_uint (&input_buf
[24]);
11425 digest
[4] = hex_to_uint (&input_buf
[32]);
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 sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11438 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11440 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11442 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11443 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11444 digest
[2] = hex_to_uint (&input_buf
[16]);
11445 digest
[3] = hex_to_uint (&input_buf
[24]);
11446 digest
[4] = hex_to_uint (&input_buf
[32]);
11448 return (PARSER_OK
);
11451 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11453 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11455 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11459 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11462 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11464 salt_t
*salt
= hash_buf
->salt
;
11466 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11467 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11468 digest
[2] = hex_to_uint (&input_buf
[16]);
11469 digest
[3] = hex_to_uint (&input_buf
[24]);
11470 digest
[4] = hex_to_uint (&input_buf
[32]);
11472 digest
[0] -= SHA1M_A
;
11473 digest
[1] -= SHA1M_B
;
11474 digest
[2] -= SHA1M_C
;
11475 digest
[3] -= SHA1M_D
;
11476 digest
[4] -= SHA1M_E
;
11478 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11480 uint salt_len
= input_len
- 40 - 1;
11482 char *salt_buf
= input_buf
+ 40 + 1;
11484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11486 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11488 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11490 salt
->salt_len
= salt_len
;
11492 return (PARSER_OK
);
11495 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11497 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11499 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11501 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11505 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11507 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11509 memcpy (digest
, tmp_buf
, 20);
11511 digest
[0] = byte_swap_32 (digest
[0]);
11512 digest
[1] = byte_swap_32 (digest
[1]);
11513 digest
[2] = byte_swap_32 (digest
[2]);
11514 digest
[3] = byte_swap_32 (digest
[3]);
11515 digest
[4] = byte_swap_32 (digest
[4]);
11517 digest
[0] -= SHA1M_A
;
11518 digest
[1] -= SHA1M_B
;
11519 digest
[2] -= SHA1M_C
;
11520 digest
[3] -= SHA1M_D
;
11521 digest
[4] -= SHA1M_E
;
11523 return (PARSER_OK
);
11526 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11528 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11530 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11532 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11534 salt_t
*salt
= hash_buf
->salt
;
11538 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11540 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11542 memcpy (digest
, tmp_buf
, 20);
11544 salt
->salt_len
= tmp_len
- 20;
11546 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11548 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11550 char *ptr
= (char *) salt
->salt_buf
;
11552 ptr
[salt
->salt_len
] = 0x80;
11555 digest
[0] = byte_swap_32 (digest
[0]);
11556 digest
[1] = byte_swap_32 (digest
[1]);
11557 digest
[2] = byte_swap_32 (digest
[2]);
11558 digest
[3] = byte_swap_32 (digest
[3]);
11559 digest
[4] = byte_swap_32 (digest
[4]);
11561 digest
[0] -= SHA1M_A
;
11562 digest
[1] -= SHA1M_B
;
11563 digest
[2] -= SHA1M_C
;
11564 digest
[3] -= SHA1M_D
;
11565 digest
[4] -= SHA1M_E
;
11567 return (PARSER_OK
);
11570 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11572 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11574 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11576 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11578 salt_t
*salt
= hash_buf
->salt
;
11580 char *salt_buf
= input_buf
+ 6;
11584 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11586 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11588 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11590 salt
->salt_len
= salt_len
;
11592 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11594 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11595 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11596 digest
[2] = hex_to_uint (&hash_pos
[16]);
11597 digest
[3] = hex_to_uint (&hash_pos
[24]);
11598 digest
[4] = hex_to_uint (&hash_pos
[32]);
11600 digest
[0] -= SHA1M_A
;
11601 digest
[1] -= SHA1M_B
;
11602 digest
[2] -= SHA1M_C
;
11603 digest
[3] -= SHA1M_D
;
11604 digest
[4] -= SHA1M_E
;
11606 return (PARSER_OK
);
11609 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11611 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11613 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11615 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11617 salt_t
*salt
= hash_buf
->salt
;
11619 char *salt_buf
= input_buf
+ 6;
11623 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11625 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11627 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11629 salt
->salt_len
= salt_len
;
11631 char *hash_pos
= input_buf
+ 6 + 8;
11633 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11634 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11635 digest
[2] = hex_to_uint (&hash_pos
[16]);
11636 digest
[3] = hex_to_uint (&hash_pos
[24]);
11637 digest
[4] = hex_to_uint (&hash_pos
[32]);
11639 digest
[0] -= SHA1M_A
;
11640 digest
[1] -= SHA1M_B
;
11641 digest
[2] -= SHA1M_C
;
11642 digest
[3] -= SHA1M_D
;
11643 digest
[4] -= SHA1M_E
;
11645 return (PARSER_OK
);
11648 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11650 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11652 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11654 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11656 salt_t
*salt
= hash_buf
->salt
;
11658 char *salt_buf
= input_buf
+ 6;
11662 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11664 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11666 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11668 salt
->salt_len
= salt_len
;
11670 char *hash_pos
= input_buf
+ 6 + 8;
11672 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11673 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11674 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11675 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11676 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11677 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11678 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11679 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11681 digest
[0] -= SHA512M_A
;
11682 digest
[1] -= SHA512M_B
;
11683 digest
[2] -= SHA512M_C
;
11684 digest
[3] -= SHA512M_D
;
11685 digest
[4] -= SHA512M_E
;
11686 digest
[5] -= SHA512M_F
;
11687 digest
[6] -= SHA512M_G
;
11688 digest
[7] -= SHA512M_H
;
11690 return (PARSER_OK
);
11693 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11695 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11697 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11701 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11704 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11706 salt_t
*salt
= hash_buf
->salt
;
11708 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11709 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11713 digest
[0] = byte_swap_32 (digest
[0]);
11714 digest
[1] = byte_swap_32 (digest
[1]);
11716 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11718 uint salt_len
= input_len
- 16 - 1;
11720 char *salt_buf
= input_buf
+ 16 + 1;
11722 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11724 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11726 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11728 salt
->salt_len
= salt_len
;
11730 return (PARSER_OK
);
11733 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11735 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11737 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11739 salt_t
*salt
= hash_buf
->salt
;
11741 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11742 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11743 digest
[2] = hex_to_uint (&input_buf
[16]);
11744 digest
[3] = hex_to_uint (&input_buf
[24]);
11745 digest
[4] = hex_to_uint (&input_buf
[32]);
11747 digest
[0] -= SHA1M_A
;
11748 digest
[1] -= SHA1M_B
;
11749 digest
[2] -= SHA1M_C
;
11750 digest
[3] -= SHA1M_D
;
11751 digest
[4] -= SHA1M_E
;
11753 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11755 uint salt_len
= input_len
- 40 - 1;
11757 char *salt_buf
= input_buf
+ 40 + 1;
11759 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11761 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11763 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11765 salt
->salt_len
= salt_len
;
11767 return (PARSER_OK
);
11770 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11772 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11774 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11776 salt_t
*salt
= hash_buf
->salt
;
11778 char *hash_pos
= input_buf
;
11780 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11781 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11782 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11783 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11784 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11785 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11786 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11787 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11788 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11789 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11790 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11791 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11792 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11793 digest
[13] = hex_to_uint (&hash_pos
[104]);
11794 digest
[14] = hex_to_uint (&hash_pos
[112]);
11795 digest
[15] = hex_to_uint (&hash_pos
[120]);
11797 char *salt_pos
= input_buf
+ 128;
11799 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11800 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11801 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11802 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11804 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11805 salt
->salt_len
= 16;
11807 return (PARSER_OK
);
11810 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11812 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11814 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11816 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11817 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11818 digest
[2] = hex_to_uint (&input_buf
[16]);
11819 digest
[3] = hex_to_uint (&input_buf
[24]);
11820 digest
[4] = hex_to_uint (&input_buf
[32]);
11821 digest
[5] = hex_to_uint (&input_buf
[40]);
11822 digest
[6] = hex_to_uint (&input_buf
[48]);
11823 digest
[7] = hex_to_uint (&input_buf
[56]);
11825 digest
[0] -= SHA256M_A
;
11826 digest
[1] -= SHA256M_B
;
11827 digest
[2] -= SHA256M_C
;
11828 digest
[3] -= SHA256M_D
;
11829 digest
[4] -= SHA256M_E
;
11830 digest
[5] -= SHA256M_F
;
11831 digest
[6] -= SHA256M_G
;
11832 digest
[7] -= SHA256M_H
;
11834 return (PARSER_OK
);
11837 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11839 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11841 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11845 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11848 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11850 salt_t
*salt
= hash_buf
->salt
;
11852 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11853 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11854 digest
[2] = hex_to_uint (&input_buf
[16]);
11855 digest
[3] = hex_to_uint (&input_buf
[24]);
11856 digest
[4] = hex_to_uint (&input_buf
[32]);
11857 digest
[5] = hex_to_uint (&input_buf
[40]);
11858 digest
[6] = hex_to_uint (&input_buf
[48]);
11859 digest
[7] = hex_to_uint (&input_buf
[56]);
11861 digest
[0] -= SHA256M_A
;
11862 digest
[1] -= SHA256M_B
;
11863 digest
[2] -= SHA256M_C
;
11864 digest
[3] -= SHA256M_D
;
11865 digest
[4] -= SHA256M_E
;
11866 digest
[5] -= SHA256M_F
;
11867 digest
[6] -= SHA256M_G
;
11868 digest
[7] -= SHA256M_H
;
11870 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11872 uint salt_len
= input_len
- 64 - 1;
11874 char *salt_buf
= input_buf
+ 64 + 1;
11876 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11878 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11880 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11882 salt
->salt_len
= salt_len
;
11884 return (PARSER_OK
);
11887 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11889 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11891 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11893 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11894 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11895 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11896 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11897 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11898 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11902 digest
[0] -= SHA384M_A
;
11903 digest
[1] -= SHA384M_B
;
11904 digest
[2] -= SHA384M_C
;
11905 digest
[3] -= SHA384M_D
;
11906 digest
[4] -= SHA384M_E
;
11907 digest
[5] -= SHA384M_F
;
11911 return (PARSER_OK
);
11914 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11916 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11918 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11920 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11921 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11922 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11923 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11924 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11925 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11926 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11927 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11929 digest
[0] -= SHA512M_A
;
11930 digest
[1] -= SHA512M_B
;
11931 digest
[2] -= SHA512M_C
;
11932 digest
[3] -= SHA512M_D
;
11933 digest
[4] -= SHA512M_E
;
11934 digest
[5] -= SHA512M_F
;
11935 digest
[6] -= SHA512M_G
;
11936 digest
[7] -= SHA512M_H
;
11938 return (PARSER_OK
);
11941 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11943 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11945 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11949 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11952 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11954 salt_t
*salt
= hash_buf
->salt
;
11956 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11957 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11958 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11959 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11960 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11961 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11962 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11963 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11965 digest
[0] -= SHA512M_A
;
11966 digest
[1] -= SHA512M_B
;
11967 digest
[2] -= SHA512M_C
;
11968 digest
[3] -= SHA512M_D
;
11969 digest
[4] -= SHA512M_E
;
11970 digest
[5] -= SHA512M_F
;
11971 digest
[6] -= SHA512M_G
;
11972 digest
[7] -= SHA512M_H
;
11974 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11976 uint salt_len
= input_len
- 128 - 1;
11978 char *salt_buf
= input_buf
+ 128 + 1;
11980 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11982 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11984 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11986 salt
->salt_len
= salt_len
;
11988 return (PARSER_OK
);
11991 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11993 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11995 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11997 salt_t
*salt
= hash_buf
->salt
;
11999 char *salt_pos
= input_buf
+ 3;
12001 uint iterations_len
= 0;
12003 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12007 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12009 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12010 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12014 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12018 iterations_len
+= 8;
12022 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12025 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12027 char *hash_pos
= strchr (salt_pos
, '$');
12029 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12031 uint salt_len
= hash_pos
- salt_pos
;
12033 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12035 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12037 salt
->salt_len
= salt_len
;
12041 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12043 return (PARSER_OK
);
12046 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12048 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12050 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12052 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12054 salt_t
*salt
= hash_buf
->salt
;
12056 uint keccak_mdlen
= input_len
/ 2;
12058 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12060 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
12062 digest
[i
] = byte_swap_64 (digest
[i
]);
12065 salt
->keccak_mdlen
= keccak_mdlen
;
12067 return (PARSER_OK
);
12070 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12072 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12074 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12076 salt_t
*salt
= hash_buf
->salt
;
12078 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12081 * Parse that strange long line
12088 in_off
[0] = strtok (input_buf
, ":");
12090 in_len
[0] = strlen (in_off
[0]);
12094 for (i
= 1; i
< 9; i
++)
12096 in_off
[i
] = strtok (NULL
, ":");
12098 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12100 in_len
[i
] = strlen (in_off
[i
]);
12105 ptr
= (char *) ikepsk
->msg_buf
;
12107 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12108 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12109 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12110 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12111 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12112 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12116 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12118 ptr
= (char *) ikepsk
->nr_buf
;
12120 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12121 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12125 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12128 * Store to database
12133 digest
[0] = hex_to_uint (&ptr
[ 0]);
12134 digest
[1] = hex_to_uint (&ptr
[ 8]);
12135 digest
[2] = hex_to_uint (&ptr
[16]);
12136 digest
[3] = hex_to_uint (&ptr
[24]);
12138 digest
[0] = byte_swap_32 (digest
[0]);
12139 digest
[1] = byte_swap_32 (digest
[1]);
12140 digest
[2] = byte_swap_32 (digest
[2]);
12141 digest
[3] = byte_swap_32 (digest
[3]);
12143 salt
->salt_len
= 32;
12145 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12146 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12147 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12148 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12149 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12150 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12151 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12152 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12154 return (PARSER_OK
);
12157 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12159 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12161 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12163 salt_t
*salt
= hash_buf
->salt
;
12165 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12168 * Parse that strange long line
12175 in_off
[0] = strtok (input_buf
, ":");
12177 in_len
[0] = strlen (in_off
[0]);
12181 for (i
= 1; i
< 9; i
++)
12183 in_off
[i
] = strtok (NULL
, ":");
12185 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12187 in_len
[i
] = strlen (in_off
[i
]);
12192 ptr
= (char *) ikepsk
->msg_buf
;
12194 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12195 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12196 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12197 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12198 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12199 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12203 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12205 ptr
= (char *) ikepsk
->nr_buf
;
12207 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12208 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12212 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12215 * Store to database
12220 digest
[0] = hex_to_uint (&ptr
[ 0]);
12221 digest
[1] = hex_to_uint (&ptr
[ 8]);
12222 digest
[2] = hex_to_uint (&ptr
[16]);
12223 digest
[3] = hex_to_uint (&ptr
[24]);
12224 digest
[4] = hex_to_uint (&ptr
[32]);
12226 salt
->salt_len
= 32;
12228 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12229 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12230 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12231 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12232 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12233 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12234 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12235 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12237 return (PARSER_OK
);
12240 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12242 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12244 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12246 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12247 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12248 digest
[2] = hex_to_uint (&input_buf
[16]);
12249 digest
[3] = hex_to_uint (&input_buf
[24]);
12250 digest
[4] = hex_to_uint (&input_buf
[32]);
12252 digest
[0] = byte_swap_32 (digest
[0]);
12253 digest
[1] = byte_swap_32 (digest
[1]);
12254 digest
[2] = byte_swap_32 (digest
[2]);
12255 digest
[3] = byte_swap_32 (digest
[3]);
12256 digest
[4] = byte_swap_32 (digest
[4]);
12258 return (PARSER_OK
);
12261 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12263 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12265 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12267 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12268 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12269 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12270 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12271 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12272 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12273 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12274 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12275 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12276 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12277 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12278 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12279 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12280 digest
[13] = hex_to_uint (&input_buf
[104]);
12281 digest
[14] = hex_to_uint (&input_buf
[112]);
12282 digest
[15] = hex_to_uint (&input_buf
[120]);
12284 return (PARSER_OK
);
12287 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12289 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12291 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12293 salt_t
*salt
= hash_buf
->salt
;
12295 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12296 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12297 digest
[2] = hex_to_uint (&input_buf
[16]);
12298 digest
[3] = hex_to_uint (&input_buf
[24]);
12299 digest
[4] = hex_to_uint (&input_buf
[32]);
12301 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12303 uint salt_len
= input_len
- 40 - 1;
12305 char *salt_buf
= input_buf
+ 40 + 1;
12307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12313 salt
->salt_len
= salt_len
;
12315 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12317 return (PARSER_OK
);
12320 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12322 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12324 salt_t
*salt
= hash_buf
->salt
;
12326 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12328 if (input_len
== 0)
12330 log_error ("TrueCrypt container not specified");
12335 FILE *fp
= fopen (input_buf
, "rb");
12339 log_error ("%s: %s", input_buf
, strerror (errno
));
12346 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12350 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12352 memcpy (tc
->salt_buf
, buf
, 64);
12354 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12356 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12358 salt
->salt_len
= 4;
12360 salt
->salt_iter
= 1000 - 1;
12362 digest
[0] = tc
->data_buf
[0];
12364 return (PARSER_OK
);
12367 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12369 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12371 salt_t
*salt
= hash_buf
->salt
;
12373 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12375 if (input_len
== 0)
12377 log_error ("TrueCrypt container not specified");
12382 FILE *fp
= fopen (input_buf
, "rb");
12386 log_error ("%s: %s", input_buf
, strerror (errno
));
12393 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12397 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12399 memcpy (tc
->salt_buf
, buf
, 64);
12401 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12403 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12405 salt
->salt_len
= 4;
12407 salt
->salt_iter
= 2000 - 1;
12409 digest
[0] = tc
->data_buf
[0];
12411 return (PARSER_OK
);
12414 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12416 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12418 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12420 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12422 salt_t
*salt
= hash_buf
->salt
;
12424 char *salt_pos
= input_buf
+ 6;
12426 char *hash_pos
= strchr (salt_pos
, '$');
12428 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12430 uint salt_len
= hash_pos
- salt_pos
;
12432 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12434 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12436 salt
->salt_len
= salt_len
;
12438 salt
->salt_iter
= 1000;
12442 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12444 return (PARSER_OK
);
12447 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12449 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12451 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12453 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12455 salt_t
*salt
= hash_buf
->salt
;
12457 char *iter_pos
= input_buf
+ 7;
12459 char *salt_pos
= strchr (iter_pos
, '$');
12461 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12465 char *hash_pos
= strchr (salt_pos
, '$');
12467 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12469 uint salt_len
= hash_pos
- salt_pos
;
12471 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12473 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12475 salt
->salt_len
= salt_len
;
12477 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12479 salt
->salt_sign
[0] = atoi (salt_iter
);
12481 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12485 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12487 digest
[0] = byte_swap_32 (digest
[0]);
12488 digest
[1] = byte_swap_32 (digest
[1]);
12489 digest
[2] = byte_swap_32 (digest
[2]);
12490 digest
[3] = byte_swap_32 (digest
[3]);
12491 digest
[4] = byte_swap_32 (digest
[4]);
12493 return (PARSER_OK
);
12496 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12498 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12500 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12502 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12504 salt_t
*salt
= hash_buf
->salt
;
12506 char *iter_pos
= input_buf
+ 9;
12508 char *salt_pos
= strchr (iter_pos
, '$');
12510 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12514 char *hash_pos
= strchr (salt_pos
, '$');
12516 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12518 uint salt_len
= hash_pos
- salt_pos
;
12520 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12522 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12524 salt
->salt_len
= salt_len
;
12526 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12528 salt
->salt_sign
[0] = atoi (salt_iter
);
12530 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12534 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12536 digest
[0] = byte_swap_32 (digest
[0]);
12537 digest
[1] = byte_swap_32 (digest
[1]);
12538 digest
[2] = byte_swap_32 (digest
[2]);
12539 digest
[3] = byte_swap_32 (digest
[3]);
12540 digest
[4] = byte_swap_32 (digest
[4]);
12541 digest
[5] = byte_swap_32 (digest
[5]);
12542 digest
[6] = byte_swap_32 (digest
[6]);
12543 digest
[7] = byte_swap_32 (digest
[7]);
12545 return (PARSER_OK
);
12548 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12550 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12552 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12554 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12556 salt_t
*salt
= hash_buf
->salt
;
12558 char *iter_pos
= input_buf
+ 9;
12560 char *salt_pos
= strchr (iter_pos
, '$');
12562 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12566 char *hash_pos
= strchr (salt_pos
, '$');
12568 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12570 uint salt_len
= hash_pos
- salt_pos
;
12572 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12574 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12576 salt
->salt_len
= salt_len
;
12578 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12580 salt
->salt_sign
[0] = atoi (salt_iter
);
12582 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12586 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12588 digest
[0] = byte_swap_64 (digest
[0]);
12589 digest
[1] = byte_swap_64 (digest
[1]);
12590 digest
[2] = byte_swap_64 (digest
[2]);
12591 digest
[3] = byte_swap_64 (digest
[3]);
12592 digest
[4] = byte_swap_64 (digest
[4]);
12593 digest
[5] = byte_swap_64 (digest
[5]);
12594 digest
[6] = byte_swap_64 (digest
[6]);
12595 digest
[7] = byte_swap_64 (digest
[7]);
12597 return (PARSER_OK
);
12600 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12602 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12604 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12606 salt_t
*salt
= hash_buf
->salt
;
12608 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12614 char *iterations_pos
= input_buf
;
12616 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12618 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12620 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12622 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12626 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12628 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12630 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12632 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12634 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12636 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12641 * pbkdf2 iterations
12644 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12647 * handle salt encoding
12650 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12652 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12654 const char p0
= saltbuf_pos
[i
+ 0];
12655 const char p1
= saltbuf_pos
[i
+ 1];
12657 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12658 | hex_convert (p0
) << 4;
12661 salt
->salt_len
= saltbuf_len
/ 2;
12664 * handle cipher encoding
12667 uint
*tmp
= (uint
*) mymalloc (32);
12669 char *cipherbuf_ptr
= (char *) tmp
;
12671 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12673 const char p0
= cipherbuf_pos
[i
+ 0];
12674 const char p1
= cipherbuf_pos
[i
+ 1];
12676 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12677 | hex_convert (p0
) << 4;
12680 // iv is stored at salt_buf 4 (length 16)
12681 // data is stored at salt_buf 8 (length 16)
12683 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12684 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12685 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12686 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12688 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12689 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12690 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12691 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12695 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12697 const char p0
= cipherbuf_pos
[j
+ 0];
12698 const char p1
= cipherbuf_pos
[j
+ 1];
12700 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12701 | hex_convert (p0
) << 4;
12708 digest
[0] = 0x10101010;
12709 digest
[1] = 0x10101010;
12710 digest
[2] = 0x10101010;
12711 digest
[3] = 0x10101010;
12713 return (PARSER_OK
);
12716 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12718 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12720 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12722 salt_t
*salt
= hash_buf
->salt
;
12724 char *hashbuf_pos
= input_buf
;
12726 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12728 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12730 uint hash_len
= iterations_pos
- hashbuf_pos
;
12732 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12736 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12738 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12740 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12744 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12746 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12750 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12752 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12754 salt
->salt_len
= salt_len
;
12756 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12758 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12759 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12760 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12761 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12763 return (PARSER_OK
);
12766 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12768 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12770 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12772 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12773 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12774 digest
[2] = hex_to_uint (&input_buf
[16]);
12775 digest
[3] = hex_to_uint (&input_buf
[24]);
12776 digest
[4] = hex_to_uint (&input_buf
[32]);
12777 digest
[5] = hex_to_uint (&input_buf
[40]);
12778 digest
[6] = hex_to_uint (&input_buf
[48]);
12779 digest
[7] = hex_to_uint (&input_buf
[56]);
12781 digest
[0] = byte_swap_32 (digest
[0]);
12782 digest
[1] = byte_swap_32 (digest
[1]);
12783 digest
[2] = byte_swap_32 (digest
[2]);
12784 digest
[3] = byte_swap_32 (digest
[3]);
12785 digest
[4] = byte_swap_32 (digest
[4]);
12786 digest
[5] = byte_swap_32 (digest
[5]);
12787 digest
[6] = byte_swap_32 (digest
[6]);
12788 digest
[7] = byte_swap_32 (digest
[7]);
12790 return (PARSER_OK
);
12793 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12795 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12797 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12799 salt_t
*salt
= hash_buf
->salt
;
12801 char *salt_pos
= input_buf
+ 3;
12803 uint iterations_len
= 0;
12805 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12809 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12811 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12812 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12816 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12820 iterations_len
+= 8;
12824 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12827 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12829 char *hash_pos
= strchr (salt_pos
, '$');
12831 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12833 uint salt_len
= hash_pos
- salt_pos
;
12835 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12837 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12839 salt
->salt_len
= salt_len
;
12843 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12845 return (PARSER_OK
);
12848 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12850 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12852 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12854 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12856 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12858 salt_t
*salt
= hash_buf
->salt
;
12860 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12862 char *iter_pos
= input_buf
+ 4;
12864 char *salt_pos
= strchr (iter_pos
, '$');
12866 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12870 char *hash_pos
= strchr (salt_pos
, '$');
12872 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12874 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12878 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12879 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12880 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12881 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12882 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12883 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12884 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12885 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12887 uint salt_len
= hash_pos
- salt_pos
- 1;
12889 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12891 salt
->salt_len
= salt_len
/ 2;
12893 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12894 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12895 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12896 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12897 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12898 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12899 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12900 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12902 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12903 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12904 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12905 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12906 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12907 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12908 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12909 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12910 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12911 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12913 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12915 salt
->salt_iter
= atoi (iter_pos
) - 1;
12917 return (PARSER_OK
);
12920 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12922 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12924 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12926 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12928 salt_t
*salt
= hash_buf
->salt
;
12930 char *salt_pos
= input_buf
+ 14;
12932 char *hash_pos
= strchr (salt_pos
, '*');
12934 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12938 uint salt_len
= hash_pos
- salt_pos
- 1;
12940 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12942 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12944 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12946 salt
->salt_len
= salt_len
;
12948 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12950 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12952 memcpy (digest
, tmp_buf
, 32);
12954 digest
[0] = byte_swap_32 (digest
[0]);
12955 digest
[1] = byte_swap_32 (digest
[1]);
12956 digest
[2] = byte_swap_32 (digest
[2]);
12957 digest
[3] = byte_swap_32 (digest
[3]);
12958 digest
[4] = byte_swap_32 (digest
[4]);
12959 digest
[5] = byte_swap_32 (digest
[5]);
12960 digest
[6] = byte_swap_32 (digest
[6]);
12961 digest
[7] = byte_swap_32 (digest
[7]);
12963 digest
[0] -= SHA256M_A
;
12964 digest
[1] -= SHA256M_B
;
12965 digest
[2] -= SHA256M_C
;
12966 digest
[3] -= SHA256M_D
;
12967 digest
[4] -= SHA256M_E
;
12968 digest
[5] -= SHA256M_F
;
12969 digest
[6] -= SHA256M_G
;
12970 digest
[7] -= SHA256M_H
;
12972 return (PARSER_OK
);
12975 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12977 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12979 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12981 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12983 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12985 salt_t
*salt
= hash_buf
->salt
;
12987 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12989 char *iter_pos
= input_buf
+ 19;
12991 char *salt_pos
= strchr (iter_pos
, '.');
12993 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12997 char *hash_pos
= strchr (salt_pos
, '.');
12999 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13001 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13005 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
13006 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
13007 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
13008 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
13009 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
13010 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
13011 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
13012 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
13014 uint salt_len
= hash_pos
- salt_pos
- 1;
13018 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13022 for (i
= 0; i
< salt_len
; i
++)
13024 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
13027 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13028 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13030 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13032 salt
->salt_len
= salt_len
;
13034 salt
->salt_iter
= atoi (iter_pos
) - 1;
13036 return (PARSER_OK
);
13039 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13041 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13043 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13045 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13047 salt_t
*salt
= hash_buf
->salt
;
13051 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13053 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
13055 memcpy (digest
, tmp_buf
, 64);
13057 digest
[0] = byte_swap_64 (digest
[0]);
13058 digest
[1] = byte_swap_64 (digest
[1]);
13059 digest
[2] = byte_swap_64 (digest
[2]);
13060 digest
[3] = byte_swap_64 (digest
[3]);
13061 digest
[4] = byte_swap_64 (digest
[4]);
13062 digest
[5] = byte_swap_64 (digest
[5]);
13063 digest
[6] = byte_swap_64 (digest
[6]);
13064 digest
[7] = byte_swap_64 (digest
[7]);
13066 digest
[0] -= SHA512M_A
;
13067 digest
[1] -= SHA512M_B
;
13068 digest
[2] -= SHA512M_C
;
13069 digest
[3] -= SHA512M_D
;
13070 digest
[4] -= SHA512M_E
;
13071 digest
[5] -= SHA512M_F
;
13072 digest
[6] -= SHA512M_G
;
13073 digest
[7] -= SHA512M_H
;
13075 salt
->salt_len
= tmp_len
- 64;
13077 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13079 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13081 char *ptr
= (char *) salt
->salt_buf
;
13083 ptr
[salt
->salt_len
] = 0x80;
13086 return (PARSER_OK
);
13089 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13091 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13093 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13097 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13100 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13102 salt_t
*salt
= hash_buf
->salt
;
13104 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13105 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13106 digest
[2] = hex_to_uint (&input_buf
[16]);
13107 digest
[3] = hex_to_uint (&input_buf
[24]);
13109 digest
[0] = byte_swap_32 (digest
[0]);
13110 digest
[1] = byte_swap_32 (digest
[1]);
13111 digest
[2] = byte_swap_32 (digest
[2]);
13112 digest
[3] = byte_swap_32 (digest
[3]);
13114 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13116 uint salt_len
= input_len
- 32 - 1;
13118 char *salt_buf
= input_buf
+ 32 + 1;
13120 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13122 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13124 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13126 salt
->salt_len
= salt_len
;
13128 return (PARSER_OK
);
13131 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13133 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13135 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13139 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13142 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13144 salt_t
*salt
= hash_buf
->salt
;
13146 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13147 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13148 digest
[2] = hex_to_uint (&input_buf
[16]);
13149 digest
[3] = hex_to_uint (&input_buf
[24]);
13150 digest
[4] = hex_to_uint (&input_buf
[32]);
13152 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13154 uint salt_len
= input_len
- 40 - 1;
13156 char *salt_buf
= input_buf
+ 40 + 1;
13158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13164 salt
->salt_len
= salt_len
;
13166 return (PARSER_OK
);
13169 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13171 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13173 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13177 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13180 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13182 salt_t
*salt
= hash_buf
->salt
;
13184 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13185 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13186 digest
[2] = hex_to_uint (&input_buf
[16]);
13187 digest
[3] = hex_to_uint (&input_buf
[24]);
13188 digest
[4] = hex_to_uint (&input_buf
[32]);
13189 digest
[5] = hex_to_uint (&input_buf
[40]);
13190 digest
[6] = hex_to_uint (&input_buf
[48]);
13191 digest
[7] = hex_to_uint (&input_buf
[56]);
13193 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13195 uint salt_len
= input_len
- 64 - 1;
13197 char *salt_buf
= input_buf
+ 64 + 1;
13199 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13201 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13203 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13205 salt
->salt_len
= salt_len
;
13207 return (PARSER_OK
);
13210 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13212 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13214 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13218 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13221 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13223 salt_t
*salt
= hash_buf
->salt
;
13225 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13226 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13227 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13228 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13229 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13230 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13231 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13232 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13234 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13236 uint salt_len
= input_len
- 128 - 1;
13238 char *salt_buf
= input_buf
+ 128 + 1;
13240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13246 salt
->salt_len
= salt_len
;
13248 return (PARSER_OK
);
13251 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13253 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13255 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13257 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13259 salt_t
*salt
= hash_buf
->salt
;
13261 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13267 char *user_pos
= input_buf
+ 10 + 1;
13269 char *realm_pos
= strchr (user_pos
, '$');
13271 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13273 uint user_len
= realm_pos
- user_pos
;
13275 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13279 char *salt_pos
= strchr (realm_pos
, '$');
13281 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13283 uint realm_len
= salt_pos
- realm_pos
;
13285 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13289 char *data_pos
= strchr (salt_pos
, '$');
13291 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13293 uint salt_len
= data_pos
- salt_pos
;
13295 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13299 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13301 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13307 memcpy (krb5pa
->user
, user_pos
, user_len
);
13308 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13309 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13311 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13313 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13315 const char p0
= data_pos
[i
+ 0];
13316 const char p1
= data_pos
[i
+ 1];
13318 *timestamp_ptr
++ = hex_convert (p1
) << 0
13319 | hex_convert (p0
) << 4;
13322 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13324 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13326 const char p0
= data_pos
[i
+ 0];
13327 const char p1
= data_pos
[i
+ 1];
13329 *checksum_ptr
++ = hex_convert (p1
) << 0
13330 | hex_convert (p0
) << 4;
13334 * copy some data to generic buffers to make sorting happy
13337 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13338 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13339 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13340 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13341 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13342 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13343 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13344 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13345 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13347 salt
->salt_len
= 36;
13349 digest
[0] = krb5pa
->checksum
[0];
13350 digest
[1] = krb5pa
->checksum
[1];
13351 digest
[2] = krb5pa
->checksum
[2];
13352 digest
[3] = krb5pa
->checksum
[3];
13354 return (PARSER_OK
);
13357 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13359 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13361 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13363 salt_t
*salt
= hash_buf
->salt
;
13369 char *salt_pos
= input_buf
;
13371 char *hash_pos
= strchr (salt_pos
, '$');
13373 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13375 uint salt_len
= hash_pos
- salt_pos
;
13377 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13381 uint hash_len
= input_len
- 1 - salt_len
;
13383 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13391 for (uint i
= 0; i
< salt_len
; i
++)
13393 if (salt_pos
[i
] == ' ') continue;
13398 // SAP user names cannot be longer than 12 characters
13399 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13401 // SAP user name cannot start with ! or ?
13402 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13408 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13410 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13412 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13414 salt
->salt_len
= salt_len
;
13416 digest
[0] = hex_to_uint (&hash_pos
[0]);
13417 digest
[1] = hex_to_uint (&hash_pos
[8]);
13421 digest
[0] = byte_swap_32 (digest
[0]);
13422 digest
[1] = byte_swap_32 (digest
[1]);
13424 return (PARSER_OK
);
13427 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13429 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13431 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13433 salt_t
*salt
= hash_buf
->salt
;
13439 char *salt_pos
= input_buf
;
13441 char *hash_pos
= strchr (salt_pos
, '$');
13443 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13445 uint salt_len
= hash_pos
- salt_pos
;
13447 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13451 uint hash_len
= input_len
- 1 - salt_len
;
13453 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13461 for (uint i
= 0; i
< salt_len
; i
++)
13463 if (salt_pos
[i
] == ' ') continue;
13468 // SAP user names cannot be longer than 12 characters
13469 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13470 // so far nobody complained so we stay with this because it helps in optimization
13471 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13473 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13475 // SAP user name cannot start with ! or ?
13476 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13482 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13484 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13486 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13488 salt
->salt_len
= salt_len
;
13490 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13491 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13492 digest
[2] = hex_to_uint (&hash_pos
[16]);
13493 digest
[3] = hex_to_uint (&hash_pos
[24]);
13494 digest
[4] = hex_to_uint (&hash_pos
[32]);
13496 return (PARSER_OK
);
13499 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13501 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13503 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13505 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13507 salt_t
*salt
= hash_buf
->salt
;
13509 char *iter_pos
= input_buf
+ 3;
13511 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13513 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13515 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13517 salt
->salt_iter
= salt_iter
;
13519 char *salt_pos
= iter_pos
+ 1;
13523 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13525 salt
->salt_len
= salt_len
;
13527 char *hash_pos
= salt_pos
+ salt_len
;
13529 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13533 char *tmp
= (char *) salt
->salt_buf_pc
;
13535 tmp
[0] = hash_pos
[42];
13539 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13540 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13541 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13542 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13548 return (PARSER_OK
);
13551 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13553 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13555 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13557 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13559 salt_t
*salt
= hash_buf
->salt
;
13561 char *salt_buf
= input_buf
+ 6;
13563 uint salt_len
= 16;
13565 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13567 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13569 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13571 salt
->salt_len
= salt_len
;
13573 char *hash_pos
= input_buf
+ 6 + 16;
13575 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13576 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13577 digest
[2] = hex_to_uint (&hash_pos
[16]);
13578 digest
[3] = hex_to_uint (&hash_pos
[24]);
13579 digest
[4] = hex_to_uint (&hash_pos
[32]);
13580 digest
[5] = hex_to_uint (&hash_pos
[40]);
13581 digest
[6] = hex_to_uint (&hash_pos
[48]);
13582 digest
[7] = hex_to_uint (&hash_pos
[56]);
13584 return (PARSER_OK
);
13587 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13589 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13591 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13593 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13594 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13598 return (PARSER_OK
);
13601 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13603 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13605 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13607 salt_t
*salt
= hash_buf
->salt
;
13609 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13611 char *saltbuf_pos
= input_buf
;
13613 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13615 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13617 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13619 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13620 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13622 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13626 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13628 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13630 char *salt_ptr
= (char *) saltbuf_pos
;
13631 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13636 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13638 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13641 rakp_ptr
[j
] = 0x80;
13643 rakp
->salt_len
= j
;
13645 for (i
= 0; i
< 64; i
++)
13647 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13650 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13651 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13652 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13653 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13654 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13655 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13656 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13657 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13659 salt
->salt_len
= 32; // muss min. 32 haben
13661 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13662 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13663 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13664 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13665 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13667 return (PARSER_OK
);
13670 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13672 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13674 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13676 salt_t
*salt
= hash_buf
->salt
;
13678 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13680 char *salt_pos
= input_buf
+ 1;
13682 memcpy (salt
->salt_buf
, salt_pos
, 8);
13684 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13685 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13687 salt
->salt_len
= 8;
13689 char *hash_pos
= salt_pos
+ 8;
13691 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13692 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13693 digest
[2] = hex_to_uint (&hash_pos
[16]);
13694 digest
[3] = hex_to_uint (&hash_pos
[24]);
13695 digest
[4] = hex_to_uint (&hash_pos
[32]);
13697 digest
[0] -= SHA1M_A
;
13698 digest
[1] -= SHA1M_B
;
13699 digest
[2] -= SHA1M_C
;
13700 digest
[3] -= SHA1M_D
;
13701 digest
[4] -= SHA1M_E
;
13703 return (PARSER_OK
);
13706 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13708 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13710 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13712 salt_t
*salt
= hash_buf
->salt
;
13714 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13715 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13716 digest
[2] = hex_to_uint (&input_buf
[16]);
13717 digest
[3] = hex_to_uint (&input_buf
[24]);
13719 digest
[0] = byte_swap_32 (digest
[0]);
13720 digest
[1] = byte_swap_32 (digest
[1]);
13721 digest
[2] = byte_swap_32 (digest
[2]);
13722 digest
[3] = byte_swap_32 (digest
[3]);
13724 digest
[0] -= MD5M_A
;
13725 digest
[1] -= MD5M_B
;
13726 digest
[2] -= MD5M_C
;
13727 digest
[3] -= MD5M_D
;
13729 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13731 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13733 uint32_t *salt_buf
= salt
->salt_buf
;
13735 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13736 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13737 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13738 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13740 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13741 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13742 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13743 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13745 salt
->salt_len
= 16 + 1;
13747 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13749 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13751 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13753 return (PARSER_OK
);
13756 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13758 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13760 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13762 salt_t
*salt
= hash_buf
->salt
;
13764 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13770 char *hashbuf_pos
= input_buf
;
13772 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13774 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13776 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13778 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13782 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13784 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13786 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13788 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13792 char *databuf_pos
= strchr (iteration_pos
, ':');
13794 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13796 const uint iteration_len
= databuf_pos
- iteration_pos
;
13798 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13799 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13801 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13803 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13804 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13810 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13811 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13812 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13813 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13814 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13815 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13816 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13817 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13821 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13823 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13825 const char p0
= saltbuf_pos
[i
+ 0];
13826 const char p1
= saltbuf_pos
[i
+ 1];
13828 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13829 | hex_convert (p0
) << 4;
13832 salt
->salt_buf
[4] = 0x01000000;
13833 salt
->salt_buf
[5] = 0x80;
13835 salt
->salt_len
= saltbuf_len
/ 2;
13839 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13843 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13845 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13847 const char p0
= databuf_pos
[i
+ 0];
13848 const char p1
= databuf_pos
[i
+ 1];
13850 *databuf_ptr
++ = hex_convert (p1
) << 0
13851 | hex_convert (p0
) << 4;
13854 *databuf_ptr
++ = 0x80;
13856 for (uint i
= 0; i
< 512; i
++)
13858 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13861 cloudkey
->data_len
= databuf_len
/ 2;
13863 return (PARSER_OK
);
13866 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13868 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13870 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13872 salt_t
*salt
= hash_buf
->salt
;
13878 char *hashbuf_pos
= input_buf
;
13880 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13882 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13884 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13886 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13890 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13892 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13894 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13896 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13898 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13902 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13904 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13906 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13908 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13910 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13914 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13916 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13917 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13919 // ok, the plan for this algorithm is the following:
13920 // we have 2 salts here, the domain-name and a random salt
13921 // while both are used in the initial transformation,
13922 // only the random salt is used in the following iterations
13923 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13924 // and one that includes only the real salt (stored into salt_buf[]).
13925 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13927 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13929 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13931 memcpy (digest
, tmp_buf
, 20);
13933 digest
[0] = byte_swap_32 (digest
[0]);
13934 digest
[1] = byte_swap_32 (digest
[1]);
13935 digest
[2] = byte_swap_32 (digest
[2]);
13936 digest
[3] = byte_swap_32 (digest
[3]);
13937 digest
[4] = byte_swap_32 (digest
[4]);
13941 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13943 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13945 char *len_ptr
= NULL
;
13947 for (uint i
= 0; i
< domainbuf_len
; i
++)
13949 if (salt_buf_pc_ptr
[i
] == '.')
13951 len_ptr
= &salt_buf_pc_ptr
[i
];
13961 salt
->salt_buf_pc
[7] = domainbuf_len
;
13965 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13967 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13969 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13971 salt
->salt_len
= salt_len
;
13975 salt
->salt_iter
= atoi (iteration_pos
);
13977 return (PARSER_OK
);
13980 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13982 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13984 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13986 salt_t
*salt
= hash_buf
->salt
;
13988 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13989 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13990 digest
[2] = hex_to_uint (&input_buf
[16]);
13991 digest
[3] = hex_to_uint (&input_buf
[24]);
13992 digest
[4] = hex_to_uint (&input_buf
[32]);
13994 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13996 uint salt_len
= input_len
- 40 - 1;
13998 char *salt_buf
= input_buf
+ 40 + 1;
14000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14006 salt
->salt_len
= salt_len
;
14008 return (PARSER_OK
);
14011 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14013 const uint8_t ascii_to_ebcdic
[] =
14015 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14016 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14017 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14018 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14019 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14020 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14021 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14022 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14023 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14024 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14025 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14026 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14027 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14028 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14029 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14030 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14033 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14035 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14037 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14039 salt_t
*salt
= hash_buf
->salt
;
14041 char *salt_pos
= input_buf
+ 6 + 1;
14043 char *digest_pos
= strchr (salt_pos
, '*');
14045 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14047 uint salt_len
= digest_pos
- salt_pos
;
14049 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14051 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14053 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14058 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14062 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14064 salt
->salt_len
= salt_len
;
14066 for (uint i
= 0; i
< salt_len
; i
++)
14068 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14070 for (uint i
= salt_len
; i
< 8; i
++)
14072 salt_buf_pc_ptr
[i
] = 0x40;
14077 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14079 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
14080 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
14082 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
14083 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
14085 digest
[0] = byte_swap_32 (digest
[0]);
14086 digest
[1] = byte_swap_32 (digest
[1]);
14088 IP (digest
[0], digest
[1], tt
);
14090 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
14091 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
14095 return (PARSER_OK
);
14098 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14100 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14102 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14104 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14105 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14106 digest
[2] = hex_to_uint (&input_buf
[16]);
14107 digest
[3] = hex_to_uint (&input_buf
[24]);
14109 digest
[0] = byte_swap_32 (digest
[0]);
14110 digest
[1] = byte_swap_32 (digest
[1]);
14111 digest
[2] = byte_swap_32 (digest
[2]);
14112 digest
[3] = byte_swap_32 (digest
[3]);
14114 return (PARSER_OK
);
14117 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14119 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14121 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14123 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14125 salt_t
*salt
= hash_buf
->salt
;
14129 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14131 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14133 tmp_buf
[3] += -4; // dont ask!
14135 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14137 salt
->salt_len
= 5;
14139 memcpy (digest
, tmp_buf
+ 5, 9);
14141 // yes, only 9 byte are needed to crack, but 10 to display
14143 salt
->salt_buf_pc
[7] = input_buf
[20];
14145 return (PARSER_OK
);
14148 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14150 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14152 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14154 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14156 salt_t
*salt
= hash_buf
->salt
;
14160 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14162 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14164 tmp_buf
[3] += -4; // dont ask!
14168 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14170 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)
14174 char tmp_iter_buf
[11];
14176 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14178 tmp_iter_buf
[10] = 0;
14180 salt
->salt_iter
= atoi (tmp_iter_buf
);
14182 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14184 return (PARSER_SALT_ITERATION
);
14187 salt
->salt_iter
--; // first round in init
14189 // 2 additional bytes for display only
14191 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14192 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14196 memcpy (digest
, tmp_buf
+ 28, 8);
14198 digest
[0] = byte_swap_32 (digest
[0]);
14199 digest
[1] = byte_swap_32 (digest
[1]);
14203 return (PARSER_OK
);
14206 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14208 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14210 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14212 salt_t
*salt
= hash_buf
->salt
;
14214 char *salt_buf_pos
= input_buf
;
14216 char *hash_buf_pos
= salt_buf_pos
+ 6;
14218 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14219 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14220 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14221 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14222 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14223 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14224 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14225 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14227 digest
[0] -= SHA256M_A
;
14228 digest
[1] -= SHA256M_B
;
14229 digest
[2] -= SHA256M_C
;
14230 digest
[3] -= SHA256M_D
;
14231 digest
[4] -= SHA256M_E
;
14232 digest
[5] -= SHA256M_F
;
14233 digest
[6] -= SHA256M_G
;
14234 digest
[7] -= SHA256M_H
;
14236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14238 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14242 salt
->salt_len
= salt_len
;
14244 return (PARSER_OK
);
14247 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14249 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14251 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14253 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14255 salt_t
*salt
= hash_buf
->salt
;
14257 char *salt_buf
= input_buf
+ 6;
14259 char *digest_buf
= strchr (salt_buf
, '$');
14261 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14263 uint salt_len
= digest_buf
- salt_buf
;
14265 digest_buf
++; // skip the '$' symbol
14267 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14269 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14273 salt
->salt_len
= salt_len
;
14275 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14276 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14277 digest
[2] = hex_to_uint (&digest_buf
[16]);
14278 digest
[3] = hex_to_uint (&digest_buf
[24]);
14280 digest
[0] = byte_swap_32 (digest
[0]);
14281 digest
[1] = byte_swap_32 (digest
[1]);
14282 digest
[2] = byte_swap_32 (digest
[2]);
14283 digest
[3] = byte_swap_32 (digest
[3]);
14285 digest
[0] -= MD5M_A
;
14286 digest
[1] -= MD5M_B
;
14287 digest
[2] -= MD5M_C
;
14288 digest
[3] -= MD5M_D
;
14290 return (PARSER_OK
);
14293 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14295 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14297 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14299 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14301 salt_t
*salt
= hash_buf
->salt
;
14303 char *salt_buf
= input_buf
+ 3;
14305 char *digest_buf
= strchr (salt_buf
, '$');
14307 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14309 uint salt_len
= digest_buf
- salt_buf
;
14311 digest_buf
++; // skip the '$' symbol
14313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14315 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14319 salt_buf_ptr
[salt_len
] = 0x2d;
14321 salt
->salt_len
= salt_len
+ 1;
14323 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14324 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14325 digest
[2] = hex_to_uint (&digest_buf
[16]);
14326 digest
[3] = hex_to_uint (&digest_buf
[24]);
14328 digest
[0] = byte_swap_32 (digest
[0]);
14329 digest
[1] = byte_swap_32 (digest
[1]);
14330 digest
[2] = byte_swap_32 (digest
[2]);
14331 digest
[3] = byte_swap_32 (digest
[3]);
14333 digest
[0] -= MD5M_A
;
14334 digest
[1] -= MD5M_B
;
14335 digest
[2] -= MD5M_C
;
14336 digest
[3] -= MD5M_D
;
14338 return (PARSER_OK
);
14341 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14343 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14345 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14349 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14351 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14353 memcpy (digest
, tmp_buf
, 20);
14355 digest
[0] = byte_swap_32 (digest
[0]);
14356 digest
[1] = byte_swap_32 (digest
[1]);
14357 digest
[2] = byte_swap_32 (digest
[2]);
14358 digest
[3] = byte_swap_32 (digest
[3]);
14359 digest
[4] = byte_swap_32 (digest
[4]);
14361 digest
[0] -= SHA1M_A
;
14362 digest
[1] -= SHA1M_B
;
14363 digest
[2] -= SHA1M_C
;
14364 digest
[3] -= SHA1M_D
;
14365 digest
[4] -= SHA1M_E
;
14367 return (PARSER_OK
);
14370 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14372 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14374 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14376 salt_t
*salt
= hash_buf
->salt
;
14378 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14379 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14380 digest
[2] = hex_to_uint (&input_buf
[16]);
14381 digest
[3] = hex_to_uint (&input_buf
[24]);
14383 digest
[0] = byte_swap_32 (digest
[0]);
14384 digest
[1] = byte_swap_32 (digest
[1]);
14385 digest
[2] = byte_swap_32 (digest
[2]);
14386 digest
[3] = byte_swap_32 (digest
[3]);
14388 digest
[0] -= MD5M_A
;
14389 digest
[1] -= MD5M_B
;
14390 digest
[2] -= MD5M_C
;
14391 digest
[3] -= MD5M_D
;
14393 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14395 uint salt_len
= input_len
- 32 - 1;
14397 char *salt_buf
= input_buf
+ 32 + 1;
14399 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14401 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14403 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14406 * add static "salt" part
14409 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14413 salt
->salt_len
= salt_len
;
14415 return (PARSER_OK
);
14418 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14420 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14422 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14424 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14426 salt_t
*salt
= hash_buf
->salt
;
14428 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14434 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14436 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14438 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14440 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14442 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14446 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14448 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14450 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14452 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14456 char *keybuf_pos
= strchr (keylen_pos
, '$');
14458 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14460 uint keylen_len
= keybuf_pos
- keylen_pos
;
14462 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14466 char *databuf_pos
= strchr (keybuf_pos
, '$');
14468 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14470 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14472 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14476 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14478 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14484 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14485 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14486 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14487 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14489 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14490 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14491 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14492 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14494 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14495 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14496 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14497 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14499 salt
->salt_len
= 16;
14500 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14502 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14504 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14507 return (PARSER_OK
);
14510 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14512 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14514 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14516 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14518 salt_t
*salt
= hash_buf
->salt
;
14524 // first is the N salt parameter
14526 char *N_pos
= input_buf
+ 6;
14528 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14532 salt
->scrypt_N
= atoi (N_pos
);
14536 char *r_pos
= strchr (N_pos
, ':');
14538 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14542 salt
->scrypt_r
= atoi (r_pos
);
14546 char *p_pos
= strchr (r_pos
, ':');
14548 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14552 salt
->scrypt_p
= atoi (p_pos
);
14556 char *saltbuf_pos
= strchr (p_pos
, ':');
14558 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14562 char *hash_pos
= strchr (saltbuf_pos
, ':');
14564 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14572 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14574 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14576 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14578 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14580 salt
->salt_len
= tmp_len
;
14581 salt
->salt_iter
= 1;
14583 // digest - base64 decode
14585 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14587 tmp_len
= input_len
- (hash_pos
- input_buf
);
14589 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14591 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14593 memcpy (digest
, tmp_buf
, 32);
14595 return (PARSER_OK
);
14598 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14600 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14602 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14604 salt_t
*salt
= hash_buf
->salt
;
14610 char decrypted
[76]; // iv + hash
14612 juniper_decrypt_hash (input_buf
, decrypted
);
14614 char *md5crypt_hash
= decrypted
+ 12;
14616 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14618 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14620 char *salt_pos
= md5crypt_hash
+ 3;
14622 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14624 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14626 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14630 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14632 return (PARSER_OK
);
14635 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14637 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14639 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14641 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14643 salt_t
*salt
= hash_buf
->salt
;
14645 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14651 // first is *raw* salt
14653 char *salt_pos
= input_buf
+ 3;
14655 char *hash_pos
= strchr (salt_pos
, '$');
14657 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14659 uint salt_len
= hash_pos
- salt_pos
;
14661 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14665 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14667 memcpy (salt_buf_ptr
, salt_pos
, 14);
14669 salt_buf_ptr
[17] = 0x01;
14670 salt_buf_ptr
[18] = 0x80;
14672 // add some stuff to normal salt to make sorted happy
14674 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14675 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14676 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14677 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14679 salt
->salt_len
= salt_len
;
14680 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14682 // base64 decode hash
14686 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14688 uint hash_len
= input_len
- 3 - salt_len
- 1;
14690 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14692 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14694 memcpy (digest
, tmp_buf
, 32);
14696 digest
[0] = byte_swap_32 (digest
[0]);
14697 digest
[1] = byte_swap_32 (digest
[1]);
14698 digest
[2] = byte_swap_32 (digest
[2]);
14699 digest
[3] = byte_swap_32 (digest
[3]);
14700 digest
[4] = byte_swap_32 (digest
[4]);
14701 digest
[5] = byte_swap_32 (digest
[5]);
14702 digest
[6] = byte_swap_32 (digest
[6]);
14703 digest
[7] = byte_swap_32 (digest
[7]);
14705 return (PARSER_OK
);
14708 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14710 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14712 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14714 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14716 salt_t
*salt
= hash_buf
->salt
;
14722 // first is *raw* salt
14724 char *salt_pos
= input_buf
+ 3;
14726 char *hash_pos
= strchr (salt_pos
, '$');
14728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14730 uint salt_len
= hash_pos
- salt_pos
;
14732 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14734 salt
->salt_len
= salt_len
;
14737 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14739 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14740 salt_buf_ptr
[salt_len
] = 0;
14742 // base64 decode hash
14746 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14748 uint hash_len
= input_len
- 3 - salt_len
- 1;
14750 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14752 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14754 memcpy (digest
, tmp_buf
, 32);
14757 salt
->scrypt_N
= 16384;
14758 salt
->scrypt_r
= 1;
14759 salt
->scrypt_p
= 1;
14760 salt
->salt_iter
= 1;
14762 return (PARSER_OK
);
14765 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14767 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14769 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14771 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14773 salt_t
*salt
= hash_buf
->salt
;
14775 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14781 char *version_pos
= input_buf
+ 8 + 1;
14783 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14785 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14787 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14789 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14791 verifierHashSize_pos
++;
14793 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14795 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14797 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14799 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14803 char *saltSize_pos
= strchr (keySize_pos
, '*');
14805 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14807 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14809 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14813 char *osalt_pos
= strchr (saltSize_pos
, '*');
14815 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14817 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14819 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14823 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14825 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14827 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14829 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14831 encryptedVerifier_pos
++;
14833 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14835 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14837 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14839 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14841 encryptedVerifierHash_pos
++;
14843 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;
14845 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14847 const uint version
= atoi (version_pos
);
14849 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14851 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14853 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14855 const uint keySize
= atoi (keySize_pos
);
14857 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14859 office2007
->keySize
= keySize
;
14861 const uint saltSize
= atoi (saltSize_pos
);
14863 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14869 salt
->salt_len
= 16;
14870 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14872 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14873 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14874 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14875 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14881 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14882 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14883 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14884 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14886 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14887 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14888 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14889 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14890 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14896 digest
[0] = office2007
->encryptedVerifierHash
[0];
14897 digest
[1] = office2007
->encryptedVerifierHash
[1];
14898 digest
[2] = office2007
->encryptedVerifierHash
[2];
14899 digest
[3] = office2007
->encryptedVerifierHash
[3];
14901 return (PARSER_OK
);
14904 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14906 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14908 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14910 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14912 salt_t
*salt
= hash_buf
->salt
;
14914 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14920 char *version_pos
= input_buf
+ 8 + 1;
14922 char *spinCount_pos
= strchr (version_pos
, '*');
14924 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14926 uint32_t version_len
= spinCount_pos
- version_pos
;
14928 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14932 char *keySize_pos
= strchr (spinCount_pos
, '*');
14934 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14936 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14938 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14942 char *saltSize_pos
= strchr (keySize_pos
, '*');
14944 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14946 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14948 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14952 char *osalt_pos
= strchr (saltSize_pos
, '*');
14954 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14958 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14962 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14964 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14966 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14968 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14970 encryptedVerifier_pos
++;
14972 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14974 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14976 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14978 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14980 encryptedVerifierHash_pos
++;
14982 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;
14984 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14986 const uint version
= atoi (version_pos
);
14988 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14990 const uint spinCount
= atoi (spinCount_pos
);
14992 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14994 const uint keySize
= atoi (keySize_pos
);
14996 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14998 const uint saltSize
= atoi (saltSize_pos
);
15000 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15006 salt
->salt_len
= 16;
15007 salt
->salt_iter
= spinCount
;
15009 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15010 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15011 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15012 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15018 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15019 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15020 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15021 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15023 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15024 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15025 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15026 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15027 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15028 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15029 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15030 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15036 digest
[0] = office2010
->encryptedVerifierHash
[0];
15037 digest
[1] = office2010
->encryptedVerifierHash
[1];
15038 digest
[2] = office2010
->encryptedVerifierHash
[2];
15039 digest
[3] = office2010
->encryptedVerifierHash
[3];
15041 return (PARSER_OK
);
15044 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15046 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15048 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15050 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15052 salt_t
*salt
= hash_buf
->salt
;
15054 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15060 char *version_pos
= input_buf
+ 8 + 1;
15062 char *spinCount_pos
= strchr (version_pos
, '*');
15064 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15066 uint32_t version_len
= spinCount_pos
- version_pos
;
15068 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15072 char *keySize_pos
= strchr (spinCount_pos
, '*');
15074 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15076 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
15078 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15082 char *saltSize_pos
= strchr (keySize_pos
, '*');
15084 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15086 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
15088 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15092 char *osalt_pos
= strchr (saltSize_pos
, '*');
15094 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15096 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
15098 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15102 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15104 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15106 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15108 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15110 encryptedVerifier_pos
++;
15112 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15114 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15116 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15118 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15120 encryptedVerifierHash_pos
++;
15122 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;
15124 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15126 const uint version
= atoi (version_pos
);
15128 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15130 const uint spinCount
= atoi (spinCount_pos
);
15132 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15134 const uint keySize
= atoi (keySize_pos
);
15136 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15138 const uint saltSize
= atoi (saltSize_pos
);
15140 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15146 salt
->salt_len
= 16;
15147 salt
->salt_iter
= spinCount
;
15149 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15150 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15151 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15152 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15158 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15159 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15160 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15161 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15163 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15164 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15165 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15166 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15167 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15168 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15169 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15170 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15176 digest
[0] = office2013
->encryptedVerifierHash
[0];
15177 digest
[1] = office2013
->encryptedVerifierHash
[1];
15178 digest
[2] = office2013
->encryptedVerifierHash
[2];
15179 digest
[3] = office2013
->encryptedVerifierHash
[3];
15181 return (PARSER_OK
);
15184 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15186 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15188 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15190 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15192 salt_t
*salt
= hash_buf
->salt
;
15194 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15200 char *version_pos
= input_buf
+ 11;
15202 char *osalt_pos
= strchr (version_pos
, '*');
15204 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15206 uint32_t version_len
= osalt_pos
- version_pos
;
15208 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15212 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15214 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15216 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15218 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15220 encryptedVerifier_pos
++;
15222 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15224 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15226 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15228 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15230 encryptedVerifierHash_pos
++;
15232 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15234 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15236 const uint version
= *version_pos
- 0x30;
15238 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15244 oldoffice01
->version
= version
;
15246 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15247 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15248 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15249 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15251 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15252 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15253 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15254 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15256 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15257 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15258 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15259 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15261 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15262 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15263 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15264 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15270 salt
->salt_len
= 16;
15272 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15273 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15274 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15275 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15277 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15278 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15279 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15280 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15282 // this is a workaround as office produces multiple documents with the same salt
15284 salt
->salt_len
+= 32;
15286 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15287 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15288 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15289 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15290 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15291 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15292 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15293 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15299 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15300 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15301 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15302 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15304 return (PARSER_OK
);
15307 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15309 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15312 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15314 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15316 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15318 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15320 salt_t
*salt
= hash_buf
->salt
;
15322 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15328 char *version_pos
= input_buf
+ 11;
15330 char *osalt_pos
= strchr (version_pos
, '*');
15332 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15334 uint32_t version_len
= osalt_pos
- version_pos
;
15336 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15340 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15342 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15344 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15346 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15348 encryptedVerifier_pos
++;
15350 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15352 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15354 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15356 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15358 encryptedVerifierHash_pos
++;
15360 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15362 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15364 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15366 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15370 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15372 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15374 const uint version
= *version_pos
- 0x30;
15376 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15382 oldoffice01
->version
= version
;
15384 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15385 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15386 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15387 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15389 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15390 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15391 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15392 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15394 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15395 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15396 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15397 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15399 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15400 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15401 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15402 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15404 oldoffice01
->rc4key
[1] = 0;
15405 oldoffice01
->rc4key
[0] = 0;
15407 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15408 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15409 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15410 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15411 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15412 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15413 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15414 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15415 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15416 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15418 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15419 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15425 salt
->salt_len
= 16;
15427 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15428 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15429 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15430 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15432 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15433 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15434 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15435 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15437 // this is a workaround as office produces multiple documents with the same salt
15439 salt
->salt_len
+= 32;
15441 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15442 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15443 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15444 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15445 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15446 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15447 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15448 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15454 digest
[0] = oldoffice01
->rc4key
[0];
15455 digest
[1] = oldoffice01
->rc4key
[1];
15459 return (PARSER_OK
);
15462 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15464 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15466 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15468 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15470 salt_t
*salt
= hash_buf
->salt
;
15472 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15478 char *version_pos
= input_buf
+ 11;
15480 char *osalt_pos
= strchr (version_pos
, '*');
15482 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15484 uint32_t version_len
= osalt_pos
- version_pos
;
15486 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15490 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15492 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15494 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15496 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15498 encryptedVerifier_pos
++;
15500 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15502 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15504 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15506 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15508 encryptedVerifierHash_pos
++;
15510 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15512 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15514 const uint version
= *version_pos
- 0x30;
15516 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15522 oldoffice34
->version
= version
;
15524 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15525 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15526 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15527 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15529 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15530 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15531 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15532 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15534 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15535 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15536 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15537 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15538 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15540 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15541 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15542 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15543 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15544 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15550 salt
->salt_len
= 16;
15552 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15553 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15554 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15555 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15557 // this is a workaround as office produces multiple documents with the same salt
15559 salt
->salt_len
+= 32;
15561 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15562 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15563 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15564 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15565 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15566 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15567 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15568 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15574 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15575 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15576 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15577 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15579 return (PARSER_OK
);
15582 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15584 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15586 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15589 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15591 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15593 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15595 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15597 salt_t
*salt
= hash_buf
->salt
;
15599 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15605 char *version_pos
= input_buf
+ 11;
15607 char *osalt_pos
= strchr (version_pos
, '*');
15609 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15611 uint32_t version_len
= osalt_pos
- version_pos
;
15613 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15617 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15619 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15621 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15623 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15625 encryptedVerifier_pos
++;
15627 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15629 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15631 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15633 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15635 encryptedVerifierHash_pos
++;
15637 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15639 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15641 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15643 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15647 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15649 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15651 const uint version
= *version_pos
- 0x30;
15653 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15659 oldoffice34
->version
= version
;
15661 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15662 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15663 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15664 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15666 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15667 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15668 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15669 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15671 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15672 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15673 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15674 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15675 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15677 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15678 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15679 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15680 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15681 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15683 oldoffice34
->rc4key
[1] = 0;
15684 oldoffice34
->rc4key
[0] = 0;
15686 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15687 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15688 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15689 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15690 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15691 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15692 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15693 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15694 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15695 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15697 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15698 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15704 salt
->salt_len
= 16;
15706 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15707 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15708 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15709 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15711 // this is a workaround as office produces multiple documents with the same salt
15713 salt
->salt_len
+= 32;
15715 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15716 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15717 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15718 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15719 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15720 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15721 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15722 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15728 digest
[0] = oldoffice34
->rc4key
[0];
15729 digest
[1] = oldoffice34
->rc4key
[1];
15733 return (PARSER_OK
);
15736 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15738 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15740 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15742 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15743 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15744 digest
[2] = hex_to_uint (&input_buf
[16]);
15745 digest
[3] = hex_to_uint (&input_buf
[24]);
15747 digest
[0] = byte_swap_32 (digest
[0]);
15748 digest
[1] = byte_swap_32 (digest
[1]);
15749 digest
[2] = byte_swap_32 (digest
[2]);
15750 digest
[3] = byte_swap_32 (digest
[3]);
15752 return (PARSER_OK
);
15755 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15757 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15759 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15761 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15763 salt_t
*salt
= hash_buf
->salt
;
15765 char *signature_pos
= input_buf
;
15767 char *salt_pos
= strchr (signature_pos
, '$');
15769 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15771 uint32_t signature_len
= salt_pos
- signature_pos
;
15773 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15777 char *hash_pos
= strchr (salt_pos
, '$');
15779 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15781 uint32_t salt_len
= hash_pos
- salt_pos
;
15783 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15787 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15789 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15791 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15792 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15793 digest
[2] = hex_to_uint (&hash_pos
[16]);
15794 digest
[3] = hex_to_uint (&hash_pos
[24]);
15795 digest
[4] = hex_to_uint (&hash_pos
[32]);
15797 digest
[0] -= SHA1M_A
;
15798 digest
[1] -= SHA1M_B
;
15799 digest
[2] -= SHA1M_C
;
15800 digest
[3] -= SHA1M_D
;
15801 digest
[4] -= SHA1M_E
;
15803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15805 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15807 salt
->salt_len
= salt_len
;
15809 return (PARSER_OK
);
15812 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15814 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15816 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15818 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15820 salt_t
*salt
= hash_buf
->salt
;
15822 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15828 char *iter_pos
= input_buf
+ 14;
15830 const int iter
= atoi (iter_pos
);
15832 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15834 salt
->salt_iter
= iter
- 1;
15836 char *salt_pos
= strchr (iter_pos
, '$');
15838 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15842 char *hash_pos
= strchr (salt_pos
, '$');
15844 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15846 const uint salt_len
= hash_pos
- salt_pos
;
15850 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15852 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15854 salt
->salt_len
= salt_len
;
15856 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15857 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15859 // add some stuff to normal salt to make sorted happy
15861 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15862 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15863 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15864 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15865 salt
->salt_buf
[4] = salt
->salt_iter
;
15867 // base64 decode hash
15871 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15873 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15875 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15877 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15879 memcpy (digest
, tmp_buf
, 32);
15881 digest
[0] = byte_swap_32 (digest
[0]);
15882 digest
[1] = byte_swap_32 (digest
[1]);
15883 digest
[2] = byte_swap_32 (digest
[2]);
15884 digest
[3] = byte_swap_32 (digest
[3]);
15885 digest
[4] = byte_swap_32 (digest
[4]);
15886 digest
[5] = byte_swap_32 (digest
[5]);
15887 digest
[6] = byte_swap_32 (digest
[6]);
15888 digest
[7] = byte_swap_32 (digest
[7]);
15890 return (PARSER_OK
);
15893 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15895 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15897 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15899 salt_t
*salt
= hash_buf
->salt
;
15901 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15902 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15906 digest
[0] = byte_swap_32 (digest
[0]);
15907 digest
[1] = byte_swap_32 (digest
[1]);
15909 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15910 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15911 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15913 char iter_c
= input_buf
[17];
15914 char iter_d
= input_buf
[19];
15916 // atm only defaults, let's see if there's more request
15917 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15918 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15920 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15922 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15923 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15924 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15925 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15927 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15928 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15929 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15930 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15932 salt
->salt_len
= 16;
15934 return (PARSER_OK
);
15937 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15939 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15941 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15943 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15945 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15947 salt_t
*salt
= hash_buf
->salt
;
15949 char *salt_pos
= input_buf
+ 10;
15951 char *hash_pos
= strchr (salt_pos
, '$');
15953 uint salt_len
= hash_pos
- salt_pos
;
15955 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15959 uint hash_len
= input_len
- 10 - salt_len
- 1;
15961 // base64 decode salt
15965 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15967 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15969 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15971 tmp_buf
[salt_len
] = 0x80;
15973 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15975 salt
->salt_len
= salt_len
;
15977 // base64 decode salt
15979 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15981 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15983 uint user_len
= hash_len
- 32;
15985 char *tmp_hash
= tmp_buf
+ user_len
;
15987 user_len
--; // skip the trailing space
15989 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15990 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15991 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15992 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15994 digest
[0] = byte_swap_32 (digest
[0]);
15995 digest
[1] = byte_swap_32 (digest
[1]);
15996 digest
[2] = byte_swap_32 (digest
[2]);
15997 digest
[3] = byte_swap_32 (digest
[3]);
15999 // store username for host only (output hash if cracked)
16001 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16002 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16004 return (PARSER_OK
);
16007 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16009 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16011 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16013 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16015 salt_t
*salt
= hash_buf
->salt
;
16017 char *iter_pos
= input_buf
+ 10;
16019 uint32_t iter
= atoi (iter_pos
);
16023 return (PARSER_SALT_ITERATION
);
16026 iter
--; // first iteration is special
16028 salt
->salt_iter
= iter
;
16030 char *base64_pos
= strchr (iter_pos
, '}');
16032 if (base64_pos
== NULL
)
16034 return (PARSER_SIGNATURE_UNMATCHED
);
16039 // base64 decode salt
16041 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
16045 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16047 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
16049 if (decoded_len
< 24)
16051 return (PARSER_SALT_LENGTH
);
16056 uint salt_len
= decoded_len
- 20;
16058 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16059 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16061 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16063 salt
->salt_len
= salt_len
;
16067 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
16069 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16070 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16071 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16072 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16073 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16075 return (PARSER_OK
);
16078 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16080 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16082 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16084 salt_t
*salt
= hash_buf
->salt
;
16086 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16087 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16088 digest
[2] = hex_to_uint (&input_buf
[16]);
16089 digest
[3] = hex_to_uint (&input_buf
[24]);
16090 digest
[4] = hex_to_uint (&input_buf
[32]);
16092 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16094 uint salt_len
= input_len
- 40 - 1;
16096 char *salt_buf
= input_buf
+ 40 + 1;
16098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16102 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16104 salt
->salt_len
= salt_len
;
16106 return (PARSER_OK
);
16109 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16111 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16113 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16115 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16117 salt_t
*salt
= hash_buf
->salt
;
16119 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16125 char *V_pos
= input_buf
+ 5;
16127 char *R_pos
= strchr (V_pos
, '*');
16129 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16131 uint32_t V_len
= R_pos
- V_pos
;
16135 char *bits_pos
= strchr (R_pos
, '*');
16137 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16139 uint32_t R_len
= bits_pos
- R_pos
;
16143 char *P_pos
= strchr (bits_pos
, '*');
16145 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16147 uint32_t bits_len
= P_pos
- bits_pos
;
16151 char *enc_md_pos
= strchr (P_pos
, '*');
16153 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16155 uint32_t P_len
= enc_md_pos
- P_pos
;
16159 char *id_len_pos
= strchr (enc_md_pos
, '*');
16161 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16163 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16167 char *id_buf_pos
= strchr (id_len_pos
, '*');
16169 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16171 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16175 char *u_len_pos
= strchr (id_buf_pos
, '*');
16177 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16179 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16181 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16185 char *u_buf_pos
= strchr (u_len_pos
, '*');
16187 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16189 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16193 char *o_len_pos
= strchr (u_buf_pos
, '*');
16195 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16197 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16199 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16203 char *o_buf_pos
= strchr (o_len_pos
, '*');
16205 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16207 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16211 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;
16213 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16217 const int V
= atoi (V_pos
);
16218 const int R
= atoi (R_pos
);
16219 const int P
= atoi (P_pos
);
16221 if (V
!= 1) return (PARSER_SALT_VALUE
);
16222 if (R
!= 2) return (PARSER_SALT_VALUE
);
16224 const int enc_md
= atoi (enc_md_pos
);
16226 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16228 const int id_len
= atoi (id_len_pos
);
16229 const int u_len
= atoi (u_len_pos
);
16230 const int o_len
= atoi (o_len_pos
);
16232 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16233 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16234 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16236 const int bits
= atoi (bits_pos
);
16238 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16240 // copy data to esalt
16246 pdf
->enc_md
= enc_md
;
16248 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16249 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16250 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16251 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16252 pdf
->id_len
= id_len
;
16254 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16255 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16256 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16257 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16258 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16259 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16260 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16261 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16262 pdf
->u_len
= u_len
;
16264 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16265 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16266 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16267 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16268 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16269 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16270 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16271 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16272 pdf
->o_len
= o_len
;
16274 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16275 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16276 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16277 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16279 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16280 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16281 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16282 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16283 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16284 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16285 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16286 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16288 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16289 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16290 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16291 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16292 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16293 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16294 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16295 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16297 // we use ID for salt, maybe needs to change, we will see...
16299 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16300 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16301 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16302 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16303 salt
->salt_len
= pdf
->id_len
;
16305 digest
[0] = pdf
->u_buf
[0];
16306 digest
[1] = pdf
->u_buf
[1];
16307 digest
[2] = pdf
->u_buf
[2];
16308 digest
[3] = pdf
->u_buf
[3];
16310 return (PARSER_OK
);
16313 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16315 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16318 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16320 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16322 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16324 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16326 salt_t
*salt
= hash_buf
->salt
;
16328 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16334 char *V_pos
= input_buf
+ 5;
16336 char *R_pos
= strchr (V_pos
, '*');
16338 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16340 uint32_t V_len
= R_pos
- V_pos
;
16344 char *bits_pos
= strchr (R_pos
, '*');
16346 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16348 uint32_t R_len
= bits_pos
- R_pos
;
16352 char *P_pos
= strchr (bits_pos
, '*');
16354 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16356 uint32_t bits_len
= P_pos
- bits_pos
;
16360 char *enc_md_pos
= strchr (P_pos
, '*');
16362 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16364 uint32_t P_len
= enc_md_pos
- P_pos
;
16368 char *id_len_pos
= strchr (enc_md_pos
, '*');
16370 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16372 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16376 char *id_buf_pos
= strchr (id_len_pos
, '*');
16378 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16380 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16384 char *u_len_pos
= strchr (id_buf_pos
, '*');
16386 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16388 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16390 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16394 char *u_buf_pos
= strchr (u_len_pos
, '*');
16396 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16398 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16402 char *o_len_pos
= strchr (u_buf_pos
, '*');
16404 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16406 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16408 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16412 char *o_buf_pos
= strchr (o_len_pos
, '*');
16414 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16416 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16420 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16422 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16424 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16426 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16430 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;
16432 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16436 const int V
= atoi (V_pos
);
16437 const int R
= atoi (R_pos
);
16438 const int P
= atoi (P_pos
);
16440 if (V
!= 1) return (PARSER_SALT_VALUE
);
16441 if (R
!= 2) return (PARSER_SALT_VALUE
);
16443 const int enc_md
= atoi (enc_md_pos
);
16445 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16447 const int id_len
= atoi (id_len_pos
);
16448 const int u_len
= atoi (u_len_pos
);
16449 const int o_len
= atoi (o_len_pos
);
16451 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16452 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16453 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16455 const int bits
= atoi (bits_pos
);
16457 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16459 // copy data to esalt
16465 pdf
->enc_md
= enc_md
;
16467 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16468 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16469 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16470 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16471 pdf
->id_len
= id_len
;
16473 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16474 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16475 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16476 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16477 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16478 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16479 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16480 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16481 pdf
->u_len
= u_len
;
16483 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16484 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16485 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16486 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16487 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16488 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16489 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16490 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16491 pdf
->o_len
= o_len
;
16493 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16494 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16495 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16496 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16498 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16499 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16500 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16501 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16502 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16503 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16504 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16505 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16507 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16508 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16509 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16510 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16511 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16512 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16513 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16514 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16516 pdf
->rc4key
[1] = 0;
16517 pdf
->rc4key
[0] = 0;
16519 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16520 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16521 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16522 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16523 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16524 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16525 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16526 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16527 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16528 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16530 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16531 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16533 // we use ID for salt, maybe needs to change, we will see...
16535 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16536 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16537 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16538 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16539 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16540 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16541 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16542 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16543 salt
->salt_len
= pdf
->id_len
+ 16;
16545 digest
[0] = pdf
->rc4key
[0];
16546 digest
[1] = pdf
->rc4key
[1];
16550 return (PARSER_OK
);
16553 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16555 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16557 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16559 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16561 salt_t
*salt
= hash_buf
->salt
;
16563 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16569 char *V_pos
= input_buf
+ 5;
16571 char *R_pos
= strchr (V_pos
, '*');
16573 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16575 uint32_t V_len
= R_pos
- V_pos
;
16579 char *bits_pos
= strchr (R_pos
, '*');
16581 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16583 uint32_t R_len
= bits_pos
- R_pos
;
16587 char *P_pos
= strchr (bits_pos
, '*');
16589 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16591 uint32_t bits_len
= P_pos
- bits_pos
;
16595 char *enc_md_pos
= strchr (P_pos
, '*');
16597 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16599 uint32_t P_len
= enc_md_pos
- P_pos
;
16603 char *id_len_pos
= strchr (enc_md_pos
, '*');
16605 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16607 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16611 char *id_buf_pos
= strchr (id_len_pos
, '*');
16613 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16615 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16619 char *u_len_pos
= strchr (id_buf_pos
, '*');
16621 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16623 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16625 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16629 char *u_buf_pos
= strchr (u_len_pos
, '*');
16631 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16633 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16637 char *o_len_pos
= strchr (u_buf_pos
, '*');
16639 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16641 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16643 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16647 char *o_buf_pos
= strchr (o_len_pos
, '*');
16649 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16651 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16655 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;
16657 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16661 const int V
= atoi (V_pos
);
16662 const int R
= atoi (R_pos
);
16663 const int P
= atoi (P_pos
);
16667 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16668 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16670 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16672 const int id_len
= atoi (id_len_pos
);
16673 const int u_len
= atoi (u_len_pos
);
16674 const int o_len
= atoi (o_len_pos
);
16676 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16678 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16679 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16681 const int bits
= atoi (bits_pos
);
16683 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16689 enc_md
= atoi (enc_md_pos
);
16692 // copy data to esalt
16698 pdf
->enc_md
= enc_md
;
16700 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16701 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16702 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16703 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16707 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16708 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16709 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16710 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16713 pdf
->id_len
= id_len
;
16715 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16716 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16717 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16718 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16719 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16720 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16721 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16722 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16723 pdf
->u_len
= u_len
;
16725 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16726 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16727 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16728 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16729 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16730 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16731 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16732 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16733 pdf
->o_len
= o_len
;
16735 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16736 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16737 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16738 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16742 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16743 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16744 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16745 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16748 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16749 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16750 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16751 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16752 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16753 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16754 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16755 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16757 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16758 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16759 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16760 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16761 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16762 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16763 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16764 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16766 // precompute rc4 data for later use
16782 uint salt_pc_block
[32];
16784 char *salt_pc_ptr
= (char *) salt_pc_block
;
16786 memcpy (salt_pc_ptr
, padding
, 32);
16787 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16789 uint salt_pc_digest
[4];
16791 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16793 pdf
->rc4data
[0] = salt_pc_digest
[0];
16794 pdf
->rc4data
[1] = salt_pc_digest
[1];
16796 // we use ID for salt, maybe needs to change, we will see...
16798 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16799 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16800 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16801 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16802 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16803 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16804 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16805 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16806 salt
->salt_len
= pdf
->id_len
+ 16;
16808 salt
->salt_iter
= ROUNDS_PDF14
;
16810 digest
[0] = pdf
->u_buf
[0];
16811 digest
[1] = pdf
->u_buf
[1];
16815 return (PARSER_OK
);
16818 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16820 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16822 if (ret
!= PARSER_OK
)
16827 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16829 salt_t
*salt
= hash_buf
->salt
;
16831 digest
[0] -= SHA256M_A
;
16832 digest
[1] -= SHA256M_B
;
16833 digest
[2] -= SHA256M_C
;
16834 digest
[3] -= SHA256M_D
;
16835 digest
[4] -= SHA256M_E
;
16836 digest
[5] -= SHA256M_F
;
16837 digest
[6] -= SHA256M_G
;
16838 digest
[7] -= SHA256M_H
;
16840 salt
->salt_buf
[2] = 0x80;
16842 return (PARSER_OK
);
16845 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16847 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16849 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16851 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16853 salt_t
*salt
= hash_buf
->salt
;
16855 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16861 char *V_pos
= input_buf
+ 5;
16863 char *R_pos
= strchr (V_pos
, '*');
16865 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16867 uint32_t V_len
= R_pos
- V_pos
;
16871 char *bits_pos
= strchr (R_pos
, '*');
16873 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16875 uint32_t R_len
= bits_pos
- R_pos
;
16879 char *P_pos
= strchr (bits_pos
, '*');
16881 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16883 uint32_t bits_len
= P_pos
- bits_pos
;
16887 char *enc_md_pos
= strchr (P_pos
, '*');
16889 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16891 uint32_t P_len
= enc_md_pos
- P_pos
;
16895 char *id_len_pos
= strchr (enc_md_pos
, '*');
16897 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16899 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16903 char *id_buf_pos
= strchr (id_len_pos
, '*');
16905 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16907 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16911 char *u_len_pos
= strchr (id_buf_pos
, '*');
16913 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16915 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16919 char *u_buf_pos
= strchr (u_len_pos
, '*');
16921 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16923 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16927 char *o_len_pos
= strchr (u_buf_pos
, '*');
16929 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16931 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16935 char *o_buf_pos
= strchr (o_len_pos
, '*');
16937 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16939 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16943 char *last
= strchr (o_buf_pos
, '*');
16945 if (last
== NULL
) last
= input_buf
+ input_len
;
16947 uint32_t o_buf_len
= last
- o_buf_pos
;
16951 const int V
= atoi (V_pos
);
16952 const int R
= atoi (R_pos
);
16956 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16957 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16959 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16961 const int bits
= atoi (bits_pos
);
16963 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16965 int enc_md
= atoi (enc_md_pos
);
16967 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16969 const uint id_len
= atoi (id_len_pos
);
16970 const uint u_len
= atoi (u_len_pos
);
16971 const uint o_len
= atoi (o_len_pos
);
16973 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16974 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16975 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16976 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16977 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16978 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16979 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16980 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16982 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16983 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16984 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16986 // copy data to esalt
16988 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16990 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16992 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16995 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16996 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16998 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16999 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17001 salt
->salt_len
= 8;
17002 salt
->salt_iter
= ROUNDS_PDF17L8
;
17004 digest
[0] = pdf
->u_buf
[0];
17005 digest
[1] = pdf
->u_buf
[1];
17006 digest
[2] = pdf
->u_buf
[2];
17007 digest
[3] = pdf
->u_buf
[3];
17008 digest
[4] = pdf
->u_buf
[4];
17009 digest
[5] = pdf
->u_buf
[5];
17010 digest
[6] = pdf
->u_buf
[6];
17011 digest
[7] = pdf
->u_buf
[7];
17013 return (PARSER_OK
);
17016 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17018 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17020 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17022 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17024 salt_t
*salt
= hash_buf
->salt
;
17026 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17034 char *iter_pos
= input_buf
+ 7;
17036 uint32_t iter
= atoi (iter_pos
);
17038 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17039 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17041 // first is *raw* salt
17043 char *salt_pos
= strchr (iter_pos
, ':');
17045 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17049 char *hash_pos
= strchr (salt_pos
, ':');
17051 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17053 uint32_t salt_len
= hash_pos
- salt_pos
;
17055 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17059 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17061 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17065 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17067 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17069 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17071 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17072 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17074 salt
->salt_len
= salt_len
;
17075 salt
->salt_iter
= iter
- 1;
17081 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17083 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17085 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17087 memcpy (digest
, tmp_buf
, 16);
17089 digest
[0] = byte_swap_32 (digest
[0]);
17090 digest
[1] = byte_swap_32 (digest
[1]);
17091 digest
[2] = byte_swap_32 (digest
[2]);
17092 digest
[3] = byte_swap_32 (digest
[3]);
17094 // add some stuff to normal salt to make sorted happy
17096 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17097 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17098 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17099 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17100 salt
->salt_buf
[4] = salt
->salt_iter
;
17102 return (PARSER_OK
);
17105 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17107 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17109 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17111 salt_t
*salt
= hash_buf
->salt
;
17113 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17114 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17115 digest
[2] = hex_to_uint (&input_buf
[16]);
17116 digest
[3] = hex_to_uint (&input_buf
[24]);
17118 digest
[0] = byte_swap_32 (digest
[0]);
17119 digest
[1] = byte_swap_32 (digest
[1]);
17120 digest
[2] = byte_swap_32 (digest
[2]);
17121 digest
[3] = byte_swap_32 (digest
[3]);
17123 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17125 uint salt_len
= input_len
- 32 - 1;
17127 char *salt_buf
= input_buf
+ 32 + 1;
17129 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17131 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17133 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17135 salt
->salt_len
= salt_len
;
17137 return (PARSER_OK
);
17140 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17142 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17144 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17146 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17148 salt_t
*salt
= hash_buf
->salt
;
17150 char *user_pos
= input_buf
+ 10;
17152 char *salt_pos
= strchr (user_pos
, '*');
17154 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17158 char *hash_pos
= strchr (salt_pos
, '*');
17162 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17164 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17166 uint user_len
= salt_pos
- user_pos
- 1;
17168 uint salt_len
= hash_pos
- salt_pos
- 1;
17170 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17176 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17177 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17178 digest
[2] = hex_to_uint (&hash_pos
[16]);
17179 digest
[3] = hex_to_uint (&hash_pos
[24]);
17181 digest
[0] = byte_swap_32 (digest
[0]);
17182 digest
[1] = byte_swap_32 (digest
[1]);
17183 digest
[2] = byte_swap_32 (digest
[2]);
17184 digest
[3] = byte_swap_32 (digest
[3]);
17186 digest
[0] -= MD5M_A
;
17187 digest
[1] -= MD5M_B
;
17188 digest
[2] -= MD5M_C
;
17189 digest
[3] -= MD5M_D
;
17195 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17197 // first 4 bytes are the "challenge"
17199 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17200 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17201 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17202 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17204 // append the user name
17206 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17208 salt
->salt_len
= 4 + user_len
;
17210 return (PARSER_OK
);
17213 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17215 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17217 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17219 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17221 salt_t
*salt
= hash_buf
->salt
;
17223 char *salt_pos
= input_buf
+ 9;
17225 char *hash_pos
= strchr (salt_pos
, '*');
17227 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17231 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17233 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17235 uint salt_len
= hash_pos
- salt_pos
- 1;
17237 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17243 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17244 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17245 digest
[2] = hex_to_uint (&hash_pos
[16]);
17246 digest
[3] = hex_to_uint (&hash_pos
[24]);
17247 digest
[4] = hex_to_uint (&hash_pos
[32]);
17253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17255 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17257 salt
->salt_len
= salt_len
;
17259 return (PARSER_OK
);
17262 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17264 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17266 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17268 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17270 salt_t
*salt
= hash_buf
->salt
;
17272 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17278 char *cry_master_len_pos
= input_buf
+ 9;
17280 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17282 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17286 cry_master_buf_pos
++;
17288 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17290 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17294 cry_salt_len_pos
++;
17296 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17298 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17302 cry_salt_buf_pos
++;
17304 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17306 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17308 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17312 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17314 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17316 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17320 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17322 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17324 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17328 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17330 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17332 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17334 public_key_len_pos
++;
17336 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17338 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17340 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17342 public_key_buf_pos
++;
17344 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;
17346 const uint cry_master_len
= atoi (cry_master_len_pos
);
17347 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17348 const uint ckey_len
= atoi (ckey_len_pos
);
17349 const uint public_key_len
= atoi (public_key_len_pos
);
17351 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17352 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17353 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17354 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17356 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17358 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17360 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17363 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17365 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17367 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17370 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17372 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17374 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17377 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17378 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17379 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17382 * store digest (should be unique enought, hopefully)
17385 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17386 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17387 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17388 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17394 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17396 const uint cry_rounds
= atoi (cry_rounds_pos
);
17398 salt
->salt_iter
= cry_rounds
- 1;
17400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17402 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17404 salt
->salt_len
= salt_len
;
17406 return (PARSER_OK
);
17409 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17411 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17413 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17415 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17417 salt_t
*salt
= hash_buf
->salt
;
17419 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17421 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17423 char temp_input_buf
[input_len
+ 1];
17425 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17426 memcpy (temp_input_buf
, input_buf
, input_len
);
17430 char *URI_server_pos
= temp_input_buf
+ 6;
17432 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17434 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17436 URI_client_pos
[0] = 0;
17439 uint URI_server_len
= strlen (URI_server_pos
);
17441 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17445 char *user_pos
= strchr (URI_client_pos
, '*');
17447 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17452 uint URI_client_len
= strlen (URI_client_pos
);
17454 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17458 char *realm_pos
= strchr (user_pos
, '*');
17460 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17465 uint user_len
= strlen (user_pos
);
17467 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17471 char *method_pos
= strchr (realm_pos
, '*');
17473 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17478 uint realm_len
= strlen (realm_pos
);
17480 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17484 char *URI_prefix_pos
= strchr (method_pos
, '*');
17486 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17488 URI_prefix_pos
[0] = 0;
17491 uint method_len
= strlen (method_pos
);
17493 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17497 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17499 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17501 URI_resource_pos
[0] = 0;
17502 URI_resource_pos
++;
17504 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17506 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17510 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17512 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17514 URI_suffix_pos
[0] = 0;
17517 uint URI_resource_len
= strlen (URI_resource_pos
);
17519 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17520 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17524 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17526 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17531 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17533 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17537 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17539 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17541 nonce_client_pos
[0] = 0;
17542 nonce_client_pos
++;
17544 uint nonce_len
= strlen (nonce_pos
);
17546 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17547 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17551 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17553 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17555 nonce_count_pos
[0] = 0;
17558 uint nonce_client_len
= strlen (nonce_client_pos
);
17560 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17564 char *qop_pos
= strchr (nonce_count_pos
, '*');
17566 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17571 uint nonce_count_len
= strlen (nonce_count_pos
);
17573 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17577 char *directive_pos
= strchr (qop_pos
, '*');
17579 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17581 directive_pos
[0] = 0;
17584 uint qop_len
= strlen (qop_pos
);
17586 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17590 char *digest_pos
= strchr (directive_pos
, '*');
17592 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17597 uint directive_len
= strlen (directive_pos
);
17599 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17601 if (memcmp (directive_pos
, "MD5", 3))
17603 log_info ("ERROR: only the MD5 directive is currently supported\n");
17605 return (PARSER_SIP_AUTH_DIRECTIVE
);
17609 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17614 uint md5_max_len
= 4 * 64;
17616 uint md5_remaining_len
= md5_max_len
;
17618 uint tmp_md5_buf
[md5_max_len
/ 4];
17620 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17622 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17624 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17626 md5_len
+= method_len
+ 1;
17627 tmp_md5_ptr
+= method_len
+ 1;
17629 if (URI_prefix_len
> 0)
17631 md5_remaining_len
= md5_max_len
- md5_len
;
17633 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17635 md5_len
+= URI_prefix_len
+ 1;
17636 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17639 md5_remaining_len
= md5_max_len
- md5_len
;
17641 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17643 md5_len
+= URI_resource_len
;
17644 tmp_md5_ptr
+= URI_resource_len
;
17646 if (URI_suffix_len
> 0)
17648 md5_remaining_len
= md5_max_len
- md5_len
;
17650 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17652 md5_len
+= 1 + URI_suffix_len
;
17655 uint tmp_digest
[4];
17657 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17659 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17660 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17661 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17662 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17668 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17670 uint esalt_len
= 0;
17672 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17674 // there are 2 possibilities for the esalt:
17676 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17678 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17680 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17682 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17694 esalt_len
= 1 + nonce_len
+ 1 + 32;
17696 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17698 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17706 // add 0x80 to esalt
17708 esalt_buf_ptr
[esalt_len
] = 0x80;
17710 sip
->esalt_len
= esalt_len
;
17716 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17718 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17720 uint max_salt_len
= 119;
17722 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17724 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17726 sip
->salt_len
= salt_len
;
17729 * fake salt (for sorting)
17732 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17736 uint fake_salt_len
= salt_len
;
17738 if (fake_salt_len
> max_salt_len
)
17740 fake_salt_len
= max_salt_len
;
17743 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17745 salt
->salt_len
= fake_salt_len
;
17751 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17752 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17753 digest
[2] = hex_to_uint (&digest_pos
[16]);
17754 digest
[3] = hex_to_uint (&digest_pos
[24]);
17756 digest
[0] = byte_swap_32 (digest
[0]);
17757 digest
[1] = byte_swap_32 (digest
[1]);
17758 digest
[2] = byte_swap_32 (digest
[2]);
17759 digest
[3] = byte_swap_32 (digest
[3]);
17761 return (PARSER_OK
);
17764 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17766 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17768 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17770 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17772 salt_t
*salt
= hash_buf
->salt
;
17776 char *digest_pos
= input_buf
;
17778 digest
[0] = hex_to_uint (&digest_pos
[0]);
17785 char *salt_buf
= input_buf
+ 8 + 1;
17789 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17791 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17793 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17795 salt
->salt_len
= salt_len
;
17797 return (PARSER_OK
);
17800 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17802 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17804 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17806 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17808 salt_t
*salt
= hash_buf
->salt
;
17810 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17816 char *p_buf_pos
= input_buf
+ 4;
17818 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17820 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17822 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17824 NumCyclesPower_pos
++;
17826 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17828 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17830 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17834 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17836 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17838 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17842 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17844 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17846 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17850 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17852 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17854 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17858 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17860 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17862 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17866 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17868 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17870 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17874 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17876 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17878 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17882 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17884 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17886 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17890 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;
17892 const uint iter
= atoi (NumCyclesPower_pos
);
17893 const uint crc
= atoi (crc_buf_pos
);
17894 const uint p_buf
= atoi (p_buf_pos
);
17895 const uint salt_len
= atoi (salt_len_pos
);
17896 const uint iv_len
= atoi (iv_len_pos
);
17897 const uint unpack_size
= atoi (unpack_size_pos
);
17898 const uint data_len
= atoi (data_len_pos
);
17904 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17905 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17907 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17909 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17911 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17917 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17918 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17919 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17920 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17922 seven_zip
->iv_len
= iv_len
;
17924 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17926 seven_zip
->salt_len
= 0;
17928 seven_zip
->crc
= crc
;
17930 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17932 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17934 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17937 seven_zip
->data_len
= data_len
;
17939 seven_zip
->unpack_size
= unpack_size
;
17943 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17944 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17945 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17946 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17948 salt
->salt_len
= 16;
17950 salt
->salt_sign
[0] = iter
;
17952 salt
->salt_iter
= 1 << iter
;
17963 return (PARSER_OK
);
17966 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17968 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17970 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17972 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17973 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17974 digest
[2] = hex_to_uint (&input_buf
[16]);
17975 digest
[3] = hex_to_uint (&input_buf
[24]);
17976 digest
[4] = hex_to_uint (&input_buf
[32]);
17977 digest
[5] = hex_to_uint (&input_buf
[40]);
17978 digest
[6] = hex_to_uint (&input_buf
[48]);
17979 digest
[7] = hex_to_uint (&input_buf
[56]);
17981 digest
[0] = byte_swap_32 (digest
[0]);
17982 digest
[1] = byte_swap_32 (digest
[1]);
17983 digest
[2] = byte_swap_32 (digest
[2]);
17984 digest
[3] = byte_swap_32 (digest
[3]);
17985 digest
[4] = byte_swap_32 (digest
[4]);
17986 digest
[5] = byte_swap_32 (digest
[5]);
17987 digest
[6] = byte_swap_32 (digest
[6]);
17988 digest
[7] = byte_swap_32 (digest
[7]);
17990 return (PARSER_OK
);
17993 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17995 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17997 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17999 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
18000 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
18001 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
18002 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
18003 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
18004 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
18005 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
18006 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
18007 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
18008 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
18009 digest
[10] = hex_to_uint (&input_buf
[ 80]);
18010 digest
[11] = hex_to_uint (&input_buf
[ 88]);
18011 digest
[12] = hex_to_uint (&input_buf
[ 96]);
18012 digest
[13] = hex_to_uint (&input_buf
[104]);
18013 digest
[14] = hex_to_uint (&input_buf
[112]);
18014 digest
[15] = hex_to_uint (&input_buf
[120]);
18016 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18017 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18018 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18019 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18020 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18021 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18022 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18023 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18024 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18025 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18026 digest
[10] = byte_swap_32 (digest
[10]);
18027 digest
[11] = byte_swap_32 (digest
[11]);
18028 digest
[12] = byte_swap_32 (digest
[12]);
18029 digest
[13] = byte_swap_32 (digest
[13]);
18030 digest
[14] = byte_swap_32 (digest
[14]);
18031 digest
[15] = byte_swap_32 (digest
[15]);
18033 return (PARSER_OK
);
18036 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18038 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18040 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18042 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18044 salt_t
*salt
= hash_buf
->salt
;
18046 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18054 char *iter_pos
= input_buf
+ 4;
18056 uint32_t iter
= atoi (iter_pos
);
18058 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18059 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18061 // first is *raw* salt
18063 char *salt_pos
= strchr (iter_pos
, ':');
18065 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18069 char *hash_pos
= strchr (salt_pos
, ':');
18071 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18073 uint32_t salt_len
= hash_pos
- salt_pos
;
18075 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18079 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18081 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18085 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18087 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18089 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18091 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18092 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18094 salt
->salt_len
= salt_len
;
18095 salt
->salt_iter
= iter
- 1;
18101 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18103 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18105 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18107 memcpy (digest
, tmp_buf
, 16);
18109 // add some stuff to normal salt to make sorted happy
18111 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18112 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18113 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18114 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18115 salt
->salt_buf
[4] = salt
->salt_iter
;
18117 return (PARSER_OK
);
18120 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18122 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18124 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18126 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18128 salt_t
*salt
= hash_buf
->salt
;
18130 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18138 char *iter_pos
= input_buf
+ 5;
18140 uint32_t iter
= atoi (iter_pos
);
18142 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18143 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18145 // first is *raw* salt
18147 char *salt_pos
= strchr (iter_pos
, ':');
18149 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18153 char *hash_pos
= strchr (salt_pos
, ':');
18155 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18157 uint32_t salt_len
= hash_pos
- salt_pos
;
18159 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18163 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18165 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18169 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18171 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18173 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18175 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18176 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18178 salt
->salt_len
= salt_len
;
18179 salt
->salt_iter
= iter
- 1;
18185 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18187 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18189 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18191 memcpy (digest
, tmp_buf
, 16);
18193 digest
[0] = byte_swap_32 (digest
[0]);
18194 digest
[1] = byte_swap_32 (digest
[1]);
18195 digest
[2] = byte_swap_32 (digest
[2]);
18196 digest
[3] = byte_swap_32 (digest
[3]);
18198 // add some stuff to normal salt to make sorted happy
18200 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18201 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18202 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18203 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18204 salt
->salt_buf
[4] = salt
->salt_iter
;
18206 return (PARSER_OK
);
18209 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18211 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18213 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18215 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18217 salt_t
*salt
= hash_buf
->salt
;
18219 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18227 char *iter_pos
= input_buf
+ 7;
18229 uint32_t iter
= atoi (iter_pos
);
18231 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18232 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18234 // first is *raw* salt
18236 char *salt_pos
= strchr (iter_pos
, ':');
18238 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18242 char *hash_pos
= strchr (salt_pos
, ':');
18244 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18246 uint32_t salt_len
= hash_pos
- salt_pos
;
18248 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18252 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18254 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18258 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18260 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18262 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18264 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18265 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18267 salt
->salt_len
= salt_len
;
18268 salt
->salt_iter
= iter
- 1;
18274 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18276 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18278 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18280 memcpy (digest
, tmp_buf
, 64);
18282 digest
[0] = byte_swap_64 (digest
[0]);
18283 digest
[1] = byte_swap_64 (digest
[1]);
18284 digest
[2] = byte_swap_64 (digest
[2]);
18285 digest
[3] = byte_swap_64 (digest
[3]);
18286 digest
[4] = byte_swap_64 (digest
[4]);
18287 digest
[5] = byte_swap_64 (digest
[5]);
18288 digest
[6] = byte_swap_64 (digest
[6]);
18289 digest
[7] = byte_swap_64 (digest
[7]);
18291 // add some stuff to normal salt to make sorted happy
18293 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18294 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18295 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18296 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18297 salt
->salt_buf
[4] = salt
->salt_iter
;
18299 return (PARSER_OK
);
18302 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18304 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18306 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18308 uint
*digest
= (uint
*) hash_buf
->digest
;
18310 salt_t
*salt
= hash_buf
->salt
;
18316 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18318 char *hash_pos
= strchr (salt_pos
, '$');
18320 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18322 uint32_t salt_len
= hash_pos
- salt_pos
;
18324 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18328 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18330 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18334 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18335 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18353 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18354 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18356 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18357 salt
->salt_len
= 8;
18359 return (PARSER_OK
);
18362 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18364 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18366 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18368 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18370 if (c19
& 3) return (PARSER_HASH_VALUE
);
18372 salt_t
*salt
= hash_buf
->salt
;
18374 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18378 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18379 | itoa64_to_int (input_buf
[2]) << 6
18380 | itoa64_to_int (input_buf
[3]) << 12
18381 | itoa64_to_int (input_buf
[4]) << 18;
18385 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18386 | itoa64_to_int (input_buf
[6]) << 6
18387 | itoa64_to_int (input_buf
[7]) << 12
18388 | itoa64_to_int (input_buf
[8]) << 18;
18390 salt
->salt_len
= 4;
18394 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18396 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18398 memcpy (digest
, tmp_buf
, 8);
18402 IP (digest
[0], digest
[1], tt
);
18404 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18405 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18409 return (PARSER_OK
);
18412 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18414 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18416 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18418 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18420 salt_t
*salt
= hash_buf
->salt
;
18426 char *type_pos
= input_buf
+ 6 + 1;
18428 char *salt_pos
= strchr (type_pos
, '*');
18430 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18432 uint32_t type_len
= salt_pos
- type_pos
;
18434 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18438 char *crypted_pos
= strchr (salt_pos
, '*');
18440 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18442 uint32_t salt_len
= crypted_pos
- salt_pos
;
18444 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18448 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18450 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18456 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18457 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18459 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18460 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18462 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18463 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18464 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18465 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18467 salt
->salt_len
= 24;
18468 salt
->salt_iter
= ROUNDS_RAR3
;
18470 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18471 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18473 digest
[0] = 0xc43d7b00;
18474 digest
[1] = 0x40070000;
18478 return (PARSER_OK
);
18481 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18483 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18485 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18487 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18489 salt_t
*salt
= hash_buf
->salt
;
18491 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18497 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18499 char *param1_pos
= strchr (param0_pos
, '$');
18501 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18503 uint32_t param0_len
= param1_pos
- param0_pos
;
18507 char *param2_pos
= strchr (param1_pos
, '$');
18509 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18511 uint32_t param1_len
= param2_pos
- param1_pos
;
18515 char *param3_pos
= strchr (param2_pos
, '$');
18517 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18519 uint32_t param2_len
= param3_pos
- param2_pos
;
18523 char *param4_pos
= strchr (param3_pos
, '$');
18525 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18527 uint32_t param3_len
= param4_pos
- param3_pos
;
18531 char *param5_pos
= strchr (param4_pos
, '$');
18533 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18535 uint32_t param4_len
= param5_pos
- param4_pos
;
18539 uint32_t param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18541 char *salt_buf
= param1_pos
;
18542 char *iv
= param3_pos
;
18543 char *pswcheck
= param5_pos
;
18545 const uint salt_len
= atoi (param0_pos
);
18546 const uint iterations
= atoi (param2_pos
);
18547 const uint pswcheck_len
= atoi (param4_pos
);
18553 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18554 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18555 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18557 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18558 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18559 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18565 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
18566 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
18567 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
18568 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
18570 rar5
->iv
[0] = hex_to_uint (&iv
[ 0]);
18571 rar5
->iv
[1] = hex_to_uint (&iv
[ 8]);
18572 rar5
->iv
[2] = hex_to_uint (&iv
[16]);
18573 rar5
->iv
[3] = hex_to_uint (&iv
[24]);
18575 salt
->salt_len
= 16;
18577 salt
->salt_sign
[0] = iterations
;
18579 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18585 digest
[0] = hex_to_uint (&pswcheck
[ 0]);
18586 digest
[1] = hex_to_uint (&pswcheck
[ 8]);
18590 return (PARSER_OK
);
18593 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18595 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18597 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18599 salt_t
*salt
= hash_buf
->salt
;
18601 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18602 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18603 digest
[2] = hex_to_uint (&input_buf
[16]);
18604 digest
[3] = hex_to_uint (&input_buf
[24]);
18605 digest
[4] = hex_to_uint (&input_buf
[32]);
18606 digest
[5] = hex_to_uint (&input_buf
[40]);
18607 digest
[6] = hex_to_uint (&input_buf
[48]);
18608 digest
[7] = hex_to_uint (&input_buf
[56]);
18610 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18612 uint salt_len
= input_len
- 64 - 1;
18614 char *salt_buf
= input_buf
+ 64 + 1;
18616 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18618 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18620 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18622 salt
->salt_len
= salt_len
;
18625 * we can precompute the first sha256 transform
18630 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18631 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18632 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18633 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18634 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18635 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18636 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18637 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18638 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18639 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18640 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18641 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18642 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18643 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18644 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18645 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18649 pc256
[0] = SHA256M_A
;
18650 pc256
[1] = SHA256M_B
;
18651 pc256
[2] = SHA256M_C
;
18652 pc256
[3] = SHA256M_D
;
18653 pc256
[4] = SHA256M_E
;
18654 pc256
[5] = SHA256M_F
;
18655 pc256
[6] = SHA256M_G
;
18656 pc256
[7] = SHA256M_H
;
18658 sha256_64 (w
, pc256
);
18660 salt
->salt_buf_pc
[0] = pc256
[0];
18661 salt
->salt_buf_pc
[1] = pc256
[1];
18662 salt
->salt_buf_pc
[2] = pc256
[2];
18663 salt
->salt_buf_pc
[3] = pc256
[3];
18664 salt
->salt_buf_pc
[4] = pc256
[4];
18665 salt
->salt_buf_pc
[5] = pc256
[5];
18666 salt
->salt_buf_pc
[6] = pc256
[6];
18667 salt
->salt_buf_pc
[7] = pc256
[7];
18669 digest
[0] -= pc256
[0];
18670 digest
[1] -= pc256
[1];
18671 digest
[2] -= pc256
[2];
18672 digest
[3] -= pc256
[3];
18673 digest
[4] -= pc256
[4];
18674 digest
[5] -= pc256
[5];
18675 digest
[6] -= pc256
[6];
18676 digest
[7] -= pc256
[7];
18678 return (PARSER_OK
);
18681 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18683 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18685 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18687 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18689 salt_t
*salt
= hash_buf
->salt
;
18695 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18697 char *data_buf_pos
= strchr (data_len_pos
, '$');
18699 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18701 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18703 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18704 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18708 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18710 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18712 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18714 uint32_t data_len
= atoi (data_len_pos
);
18716 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18722 char *salt_pos
= data_buf_pos
;
18724 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18725 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18726 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18727 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18729 // this is actually the CT, which is also the hash later (if matched)
18731 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18732 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18733 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18734 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18736 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18738 salt
->salt_iter
= 10 - 1;
18744 digest
[0] = salt
->salt_buf
[4];
18745 digest
[1] = salt
->salt_buf
[5];
18746 digest
[2] = salt
->salt_buf
[6];
18747 digest
[3] = salt
->salt_buf
[7];
18749 return (PARSER_OK
);
18752 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18754 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18756 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18758 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18760 salt_t
*salt
= hash_buf
->salt
;
18766 char *salt_pos
= input_buf
+ 11 + 1;
18768 char *iter_pos
= strchr (salt_pos
, ',');
18770 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18772 uint32_t salt_len
= iter_pos
- salt_pos
;
18774 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18778 char *hash_pos
= strchr (iter_pos
, ',');
18780 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18782 uint32_t iter_len
= hash_pos
- iter_pos
;
18784 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18788 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18790 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18796 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18797 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18798 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18799 salt
->salt_buf
[3] = 0x00018000;
18801 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18802 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18803 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18804 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18806 salt
->salt_len
= salt_len
/ 2;
18808 salt
->salt_iter
= atoi (iter_pos
) - 1;
18814 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18815 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18816 digest
[2] = hex_to_uint (&hash_pos
[16]);
18817 digest
[3] = hex_to_uint (&hash_pos
[24]);
18818 digest
[4] = hex_to_uint (&hash_pos
[32]);
18819 digest
[5] = hex_to_uint (&hash_pos
[40]);
18820 digest
[6] = hex_to_uint (&hash_pos
[48]);
18821 digest
[7] = hex_to_uint (&hash_pos
[56]);
18823 return (PARSER_OK
);
18826 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18828 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18830 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18832 salt_t
*salt
= hash_buf
->salt
;
18838 char *hash_pos
= input_buf
+ 64;
18839 char *salt1_pos
= input_buf
+ 128;
18840 char *salt2_pos
= input_buf
;
18846 salt
->salt_buf
[ 0] = hex_to_uint (&salt1_pos
[ 0]);
18847 salt
->salt_buf
[ 1] = hex_to_uint (&salt1_pos
[ 8]);
18848 salt
->salt_buf
[ 2] = hex_to_uint (&salt1_pos
[16]);
18849 salt
->salt_buf
[ 3] = hex_to_uint (&salt1_pos
[24]);
18851 salt
->salt_buf
[ 4] = hex_to_uint (&salt2_pos
[ 0]);
18852 salt
->salt_buf
[ 5] = hex_to_uint (&salt2_pos
[ 8]);
18853 salt
->salt_buf
[ 6] = hex_to_uint (&salt2_pos
[16]);
18854 salt
->salt_buf
[ 7] = hex_to_uint (&salt2_pos
[24]);
18856 salt
->salt_buf
[ 8] = hex_to_uint (&salt2_pos
[32]);
18857 salt
->salt_buf
[ 9] = hex_to_uint (&salt2_pos
[40]);
18858 salt
->salt_buf
[10] = hex_to_uint (&salt2_pos
[48]);
18859 salt
->salt_buf
[11] = hex_to_uint (&salt2_pos
[56]);
18861 salt
->salt_len
= 48;
18863 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18869 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18870 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18871 digest
[2] = hex_to_uint (&hash_pos
[16]);
18872 digest
[3] = hex_to_uint (&hash_pos
[24]);
18873 digest
[4] = hex_to_uint (&hash_pos
[32]);
18874 digest
[5] = hex_to_uint (&hash_pos
[40]);
18875 digest
[6] = hex_to_uint (&hash_pos
[48]);
18876 digest
[7] = hex_to_uint (&hash_pos
[56]);
18878 return (PARSER_OK
);
18882 * parallel running threads
18887 BOOL WINAPI
sigHandler_default (DWORD sig
)
18891 case CTRL_CLOSE_EVENT
:
18894 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18895 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18896 * function otherwise it is to late (e.g. after returning from this function)
18901 SetConsoleCtrlHandler (NULL
, TRUE
);
18908 case CTRL_LOGOFF_EVENT
:
18909 case CTRL_SHUTDOWN_EVENT
:
18913 SetConsoleCtrlHandler (NULL
, TRUE
);
18921 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18925 case CTRL_CLOSE_EVENT
:
18929 SetConsoleCtrlHandler (NULL
, TRUE
);
18936 case CTRL_LOGOFF_EVENT
:
18937 case CTRL_SHUTDOWN_EVENT
:
18941 SetConsoleCtrlHandler (NULL
, TRUE
);
18949 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18951 if (callback
== NULL
)
18953 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18957 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18963 void sigHandler_default (int sig
)
18967 signal (sig
, NULL
);
18970 void sigHandler_benchmark (int sig
)
18974 signal (sig
, NULL
);
18977 void hc_signal (void (callback
) (int))
18979 if (callback
== NULL
) callback
= SIG_DFL
;
18981 signal (SIGINT
, callback
);
18982 signal (SIGTERM
, callback
);
18983 signal (SIGABRT
, callback
);
18988 void status_display ();
18990 void *thread_keypress (void *p
)
18992 int benchmark
= *((int *) p
);
18994 uint quiet
= data
.quiet
;
18998 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19000 int ch
= tty_getchar();
19002 if (ch
== -1) break;
19004 if (ch
== 0) continue;
19010 hc_thread_mutex_lock (mux_display
);
19025 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19026 if (quiet
== 0) fflush (stdout
);
19038 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19039 if (quiet
== 0) fflush (stdout
);
19051 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19052 if (quiet
== 0) fflush (stdout
);
19064 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19065 if (quiet
== 0) fflush (stdout
);
19073 if (benchmark
== 1) break;
19075 stop_at_checkpoint ();
19079 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19080 if (quiet
== 0) fflush (stdout
);
19088 if (benchmark
== 1)
19100 hc_thread_mutex_unlock (mux_display
);
19112 bool class_num (char c
)
19114 return ((c
>= '0') && (c
<= '9'));
19117 bool class_lower (char c
)
19119 return ((c
>= 'a') && (c
<= 'z'));
19122 bool class_upper (char c
)
19124 return ((c
>= 'A') && (c
<= 'Z'));
19127 bool class_alpha (char c
)
19129 return (class_lower (c
) || class_upper (c
));
19132 char conv_ctoi (char c
)
19138 else if (class_upper (c
))
19140 return c
- 'A' + (char) 10;
19143 return (char) (-1);
19146 char conv_itoc (char c
)
19154 return c
+ 'A' - (char) 10;
19157 return (char) (-1);
19164 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19165 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19166 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19167 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19168 #define MAX_KERNEL_RULES 255
19169 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19170 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19171 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19173 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19174 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19175 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19176 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19178 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19183 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19185 switch (rule_buf
[rule_pos
])
19191 case RULE_OP_MANGLE_NOOP
:
19192 SET_NAME (rule
, rule_buf
[rule_pos
]);
19195 case RULE_OP_MANGLE_LREST
:
19196 SET_NAME (rule
, rule_buf
[rule_pos
]);
19199 case RULE_OP_MANGLE_UREST
:
19200 SET_NAME (rule
, rule_buf
[rule_pos
]);
19203 case RULE_OP_MANGLE_LREST_UFIRST
:
19204 SET_NAME (rule
, rule_buf
[rule_pos
]);
19207 case RULE_OP_MANGLE_UREST_LFIRST
:
19208 SET_NAME (rule
, rule_buf
[rule_pos
]);
19211 case RULE_OP_MANGLE_TREST
:
19212 SET_NAME (rule
, rule_buf
[rule_pos
]);
19215 case RULE_OP_MANGLE_TOGGLE_AT
:
19216 SET_NAME (rule
, rule_buf
[rule_pos
]);
19217 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19220 case RULE_OP_MANGLE_REVERSE
:
19221 SET_NAME (rule
, rule_buf
[rule_pos
]);
19224 case RULE_OP_MANGLE_DUPEWORD
:
19225 SET_NAME (rule
, rule_buf
[rule_pos
]);
19228 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19229 SET_NAME (rule
, rule_buf
[rule_pos
]);
19230 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19233 case RULE_OP_MANGLE_REFLECT
:
19234 SET_NAME (rule
, rule_buf
[rule_pos
]);
19237 case RULE_OP_MANGLE_ROTATE_LEFT
:
19238 SET_NAME (rule
, rule_buf
[rule_pos
]);
19241 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19242 SET_NAME (rule
, rule_buf
[rule_pos
]);
19245 case RULE_OP_MANGLE_APPEND
:
19246 SET_NAME (rule
, rule_buf
[rule_pos
]);
19247 SET_P0 (rule
, rule_buf
[rule_pos
]);
19250 case RULE_OP_MANGLE_PREPEND
:
19251 SET_NAME (rule
, rule_buf
[rule_pos
]);
19252 SET_P0 (rule
, rule_buf
[rule_pos
]);
19255 case RULE_OP_MANGLE_DELETE_FIRST
:
19256 SET_NAME (rule
, rule_buf
[rule_pos
]);
19259 case RULE_OP_MANGLE_DELETE_LAST
:
19260 SET_NAME (rule
, rule_buf
[rule_pos
]);
19263 case RULE_OP_MANGLE_DELETE_AT
:
19264 SET_NAME (rule
, rule_buf
[rule_pos
]);
19265 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19268 case RULE_OP_MANGLE_EXTRACT
:
19269 SET_NAME (rule
, rule_buf
[rule_pos
]);
19270 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19271 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19274 case RULE_OP_MANGLE_OMIT
:
19275 SET_NAME (rule
, rule_buf
[rule_pos
]);
19276 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19277 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19280 case RULE_OP_MANGLE_INSERT
:
19281 SET_NAME (rule
, rule_buf
[rule_pos
]);
19282 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19283 SET_P1 (rule
, rule_buf
[rule_pos
]);
19286 case RULE_OP_MANGLE_OVERSTRIKE
:
19287 SET_NAME (rule
, rule_buf
[rule_pos
]);
19288 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19289 SET_P1 (rule
, rule_buf
[rule_pos
]);
19292 case RULE_OP_MANGLE_TRUNCATE_AT
:
19293 SET_NAME (rule
, rule_buf
[rule_pos
]);
19294 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19297 case RULE_OP_MANGLE_REPLACE
:
19298 SET_NAME (rule
, rule_buf
[rule_pos
]);
19299 SET_P0 (rule
, rule_buf
[rule_pos
]);
19300 SET_P1 (rule
, rule_buf
[rule_pos
]);
19303 case RULE_OP_MANGLE_PURGECHAR
:
19307 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19311 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19312 SET_NAME (rule
, rule_buf
[rule_pos
]);
19313 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19316 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19317 SET_NAME (rule
, rule_buf
[rule_pos
]);
19318 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19321 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19322 SET_NAME (rule
, rule_buf
[rule_pos
]);
19325 case RULE_OP_MANGLE_SWITCH_FIRST
:
19326 SET_NAME (rule
, rule_buf
[rule_pos
]);
19329 case RULE_OP_MANGLE_SWITCH_LAST
:
19330 SET_NAME (rule
, rule_buf
[rule_pos
]);
19333 case RULE_OP_MANGLE_SWITCH_AT
:
19334 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19336 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19339 case RULE_OP_MANGLE_CHR_SHIFTL
:
19340 SET_NAME (rule
, rule_buf
[rule_pos
]);
19341 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19344 case RULE_OP_MANGLE_CHR_SHIFTR
:
19345 SET_NAME (rule
, rule_buf
[rule_pos
]);
19346 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19349 case RULE_OP_MANGLE_CHR_INCR
:
19350 SET_NAME (rule
, rule_buf
[rule_pos
]);
19351 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19354 case RULE_OP_MANGLE_CHR_DECR
:
19355 SET_NAME (rule
, rule_buf
[rule_pos
]);
19356 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19359 case RULE_OP_MANGLE_REPLACE_NP1
:
19360 SET_NAME (rule
, rule_buf
[rule_pos
]);
19361 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19364 case RULE_OP_MANGLE_REPLACE_NM1
:
19365 SET_NAME (rule
, rule_buf
[rule_pos
]);
19366 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19371 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19374 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19375 SET_NAME (rule
, rule_buf
[rule_pos
]);
19376 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19379 case RULE_OP_MANGLE_TITLE
:
19380 SET_NAME (rule
, rule_buf
[rule_pos
]);
19389 if (rule_pos
< rule_len
) return (-1);
19394 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19398 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19402 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19406 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19410 case RULE_OP_MANGLE_NOOP
:
19411 rule_buf
[rule_pos
] = rule_cmd
;
19414 case RULE_OP_MANGLE_LREST
:
19415 rule_buf
[rule_pos
] = rule_cmd
;
19418 case RULE_OP_MANGLE_UREST
:
19419 rule_buf
[rule_pos
] = rule_cmd
;
19422 case RULE_OP_MANGLE_LREST_UFIRST
:
19423 rule_buf
[rule_pos
] = rule_cmd
;
19426 case RULE_OP_MANGLE_UREST_LFIRST
:
19427 rule_buf
[rule_pos
] = rule_cmd
;
19430 case RULE_OP_MANGLE_TREST
:
19431 rule_buf
[rule_pos
] = rule_cmd
;
19434 case RULE_OP_MANGLE_TOGGLE_AT
:
19435 rule_buf
[rule_pos
] = rule_cmd
;
19436 GET_P0_CONV (rule
);
19439 case RULE_OP_MANGLE_REVERSE
:
19440 rule_buf
[rule_pos
] = rule_cmd
;
19443 case RULE_OP_MANGLE_DUPEWORD
:
19444 rule_buf
[rule_pos
] = rule_cmd
;
19447 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19448 rule_buf
[rule_pos
] = rule_cmd
;
19449 GET_P0_CONV (rule
);
19452 case RULE_OP_MANGLE_REFLECT
:
19453 rule_buf
[rule_pos
] = rule_cmd
;
19456 case RULE_OP_MANGLE_ROTATE_LEFT
:
19457 rule_buf
[rule_pos
] = rule_cmd
;
19460 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19461 rule_buf
[rule_pos
] = rule_cmd
;
19464 case RULE_OP_MANGLE_APPEND
:
19465 rule_buf
[rule_pos
] = rule_cmd
;
19469 case RULE_OP_MANGLE_PREPEND
:
19470 rule_buf
[rule_pos
] = rule_cmd
;
19474 case RULE_OP_MANGLE_DELETE_FIRST
:
19475 rule_buf
[rule_pos
] = rule_cmd
;
19478 case RULE_OP_MANGLE_DELETE_LAST
:
19479 rule_buf
[rule_pos
] = rule_cmd
;
19482 case RULE_OP_MANGLE_DELETE_AT
:
19483 rule_buf
[rule_pos
] = rule_cmd
;
19484 GET_P0_CONV (rule
);
19487 case RULE_OP_MANGLE_EXTRACT
:
19488 rule_buf
[rule_pos
] = rule_cmd
;
19489 GET_P0_CONV (rule
);
19490 GET_P1_CONV (rule
);
19493 case RULE_OP_MANGLE_OMIT
:
19494 rule_buf
[rule_pos
] = rule_cmd
;
19495 GET_P0_CONV (rule
);
19496 GET_P1_CONV (rule
);
19499 case RULE_OP_MANGLE_INSERT
:
19500 rule_buf
[rule_pos
] = rule_cmd
;
19501 GET_P0_CONV (rule
);
19505 case RULE_OP_MANGLE_OVERSTRIKE
:
19506 rule_buf
[rule_pos
] = rule_cmd
;
19507 GET_P0_CONV (rule
);
19511 case RULE_OP_MANGLE_TRUNCATE_AT
:
19512 rule_buf
[rule_pos
] = rule_cmd
;
19513 GET_P0_CONV (rule
);
19516 case RULE_OP_MANGLE_REPLACE
:
19517 rule_buf
[rule_pos
] = rule_cmd
;
19522 case RULE_OP_MANGLE_PURGECHAR
:
19526 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19530 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19531 rule_buf
[rule_pos
] = rule_cmd
;
19532 GET_P0_CONV (rule
);
19535 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19536 rule_buf
[rule_pos
] = rule_cmd
;
19537 GET_P0_CONV (rule
);
19540 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19541 rule_buf
[rule_pos
] = rule_cmd
;
19544 case RULE_OP_MANGLE_SWITCH_FIRST
:
19545 rule_buf
[rule_pos
] = rule_cmd
;
19548 case RULE_OP_MANGLE_SWITCH_LAST
:
19549 rule_buf
[rule_pos
] = rule_cmd
;
19552 case RULE_OP_MANGLE_SWITCH_AT
:
19553 rule_buf
[rule_pos
] = rule_cmd
;
19554 GET_P0_CONV (rule
);
19555 GET_P1_CONV (rule
);
19558 case RULE_OP_MANGLE_CHR_SHIFTL
:
19559 rule_buf
[rule_pos
] = rule_cmd
;
19560 GET_P0_CONV (rule
);
19563 case RULE_OP_MANGLE_CHR_SHIFTR
:
19564 rule_buf
[rule_pos
] = rule_cmd
;
19565 GET_P0_CONV (rule
);
19568 case RULE_OP_MANGLE_CHR_INCR
:
19569 rule_buf
[rule_pos
] = rule_cmd
;
19570 GET_P0_CONV (rule
);
19573 case RULE_OP_MANGLE_CHR_DECR
:
19574 rule_buf
[rule_pos
] = rule_cmd
;
19575 GET_P0_CONV (rule
);
19578 case RULE_OP_MANGLE_REPLACE_NP1
:
19579 rule_buf
[rule_pos
] = rule_cmd
;
19580 GET_P0_CONV (rule
);
19583 case RULE_OP_MANGLE_REPLACE_NM1
:
19584 rule_buf
[rule_pos
] = rule_cmd
;
19585 GET_P0_CONV (rule
);
19588 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19590 GET_P0_CONV (rule
);
19593 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19594 rule_buf
[rule_pos
] = rule_cmd
;
19595 GET_P0_CONV (rule
);
19598 case RULE_OP_MANGLE_TITLE
:
19599 rule_buf
[rule_pos
] = rule_cmd
;
19603 return rule_pos
- 1;
19621 * CPU rules : this is from hashcat sources, cpu based rules
19624 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19625 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19627 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19628 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19629 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19631 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19632 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19633 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19635 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19639 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19644 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19648 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19653 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19657 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19662 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19667 for (l
= 0; l
< arr_len
; l
++)
19669 r
= arr_len
- 1 - l
;
19673 MANGLE_SWITCH (arr
, l
, r
);
19679 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19681 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19683 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19685 return (arr_len
* 2);
19688 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19690 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19692 int orig_len
= arr_len
;
19696 for (i
= 0; i
< times
; i
++)
19698 memcpy (&arr
[arr_len
], arr
, orig_len
);
19700 arr_len
+= orig_len
;
19706 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19708 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19710 mangle_double (arr
, arr_len
);
19712 mangle_reverse (arr
+ arr_len
, arr_len
);
19714 return (arr_len
* 2);
19717 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19722 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19724 MANGLE_SWITCH (arr
, l
, r
);
19730 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19735 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19737 MANGLE_SWITCH (arr
, l
, r
);
19743 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19745 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19749 return (arr_len
+ 1);
19752 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19754 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19758 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19760 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19765 return (arr_len
+ 1);
19768 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19770 if (upos
>= arr_len
) return (arr_len
);
19774 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19776 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19779 return (arr_len
- 1);
19782 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19784 if (upos
>= arr_len
) return (arr_len
);
19786 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19790 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19792 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19798 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19800 if (upos
>= arr_len
) return (arr_len
);
19802 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19806 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19808 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19811 return (arr_len
- ulen
);
19814 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19816 if (upos
>= arr_len
) return (arr_len
);
19818 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19822 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19824 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19829 return (arr_len
+ 1);
19832 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
)
19834 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19836 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19838 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19840 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19842 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19844 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19846 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19848 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19850 return (arr_len
+ arr2_cpy
);
19853 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19855 if (upos
>= arr_len
) return (arr_len
);
19862 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19864 if (upos
>= arr_len
) return (arr_len
);
19866 memset (arr
+ upos
, 0, arr_len
- upos
);
19871 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19875 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19877 if (arr
[arr_pos
] != oldc
) continue;
19879 arr
[arr_pos
] = newc
;
19885 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19891 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19893 if (arr
[arr_pos
] == c
) continue;
19895 arr
[ret_len
] = arr
[arr_pos
];
19903 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19905 if (ulen
> arr_len
) return (arr_len
);
19907 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19911 memcpy (cs
, arr
, ulen
);
19915 for (i
= 0; i
< ulen
; i
++)
19919 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19925 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19927 if (ulen
> arr_len
) return (arr_len
);
19929 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19931 int upos
= arr_len
- ulen
;
19935 for (i
= 0; i
< ulen
; i
++)
19937 char c
= arr
[upos
+ i
];
19939 arr_len
= mangle_append (arr
, arr_len
, c
);
19945 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19947 if ( arr_len
== 0) return (arr_len
);
19948 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19950 char c
= arr
[upos
];
19954 for (i
= 0; i
< ulen
; i
++)
19956 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19962 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19964 if ( arr_len
== 0) return (arr_len
);
19965 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19969 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19971 int new_pos
= arr_pos
* 2;
19973 arr
[new_pos
] = arr
[arr_pos
];
19975 arr
[new_pos
+ 1] = arr
[arr_pos
];
19978 return (arr_len
* 2);
19981 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19983 if (upos
>= arr_len
) return (arr_len
);
19984 if (upos2
>= arr_len
) return (arr_len
);
19986 MANGLE_SWITCH (arr
, upos
, upos2
);
19991 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19993 MANGLE_SWITCH (arr
, upos
, upos2
);
19998 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20000 if (upos
>= arr_len
) return (arr_len
);
20007 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20009 if (upos
>= arr_len
) return (arr_len
);
20016 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20018 if (upos
>= arr_len
) return (arr_len
);
20025 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20027 if (upos
>= arr_len
) return (arr_len
);
20034 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20036 int upper_next
= 1;
20040 for (pos
= 0; pos
< arr_len
; pos
++)
20042 if (arr
[pos
] == ' ')
20053 MANGLE_UPPER_AT (arr
, pos
);
20057 MANGLE_LOWER_AT (arr
, pos
);
20064 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
20066 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20070 uint32_t rule_pos
= 0;
20072 for (j
= 0; j
< rp_gen_num
; j
++)
20079 switch ((char) get_random_num (0, 9))
20082 r
= get_random_num (0, sizeof (grp_op_nop
));
20083 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20087 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20088 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20089 p1
= get_random_num (0, sizeof (grp_pos
));
20090 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20094 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20095 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20096 p1
= get_random_num (1, 6);
20097 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20101 r
= get_random_num (0, sizeof (grp_op_chr
));
20102 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20103 p1
= get_random_num (0x20, 0x7e);
20104 rule_buf
[rule_pos
++] = (char) p1
;
20108 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20109 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20110 p1
= get_random_num (0x20, 0x7e);
20111 rule_buf
[rule_pos
++] = (char) p1
;
20112 p2
= get_random_num (0x20, 0x7e);
20114 p2
= get_random_num (0x20, 0x7e);
20115 rule_buf
[rule_pos
++] = (char) p2
;
20119 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20120 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20121 p1
= get_random_num (0, sizeof (grp_pos
));
20122 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20123 p2
= get_random_num (0x20, 0x7e);
20124 rule_buf
[rule_pos
++] = (char) p2
;
20128 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20129 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20130 p1
= get_random_num (0, sizeof (grp_pos
));
20131 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20132 p2
= get_random_num (0, sizeof (grp_pos
));
20134 p2
= get_random_num (0, sizeof (grp_pos
));
20135 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20139 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20140 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20141 p1
= get_random_num (0, sizeof (grp_pos
));
20142 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20143 p2
= get_random_num (1, sizeof (grp_pos
));
20145 p2
= get_random_num (1, sizeof (grp_pos
));
20146 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20150 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20151 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20152 p1
= get_random_num (0, sizeof (grp_pos
));
20153 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20154 p2
= get_random_num (1, sizeof (grp_pos
));
20155 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20156 p3
= get_random_num (0, sizeof (grp_pos
));
20157 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20165 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20167 char mem
[BLOCK_SIZE
];
20169 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20171 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20173 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20175 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20177 int out_len
= in_len
;
20178 int mem_len
= in_len
;
20180 memcpy (out
, in
, out_len
);
20184 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20186 int upos
; int upos2
;
20189 switch (rule
[rule_pos
])
20194 case RULE_OP_MANGLE_NOOP
:
20197 case RULE_OP_MANGLE_LREST
:
20198 out_len
= mangle_lrest (out
, out_len
);
20201 case RULE_OP_MANGLE_UREST
:
20202 out_len
= mangle_urest (out
, out_len
);
20205 case RULE_OP_MANGLE_LREST_UFIRST
:
20206 out_len
= mangle_lrest (out
, out_len
);
20207 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20210 case RULE_OP_MANGLE_UREST_LFIRST
:
20211 out_len
= mangle_urest (out
, out_len
);
20212 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20215 case RULE_OP_MANGLE_TREST
:
20216 out_len
= mangle_trest (out
, out_len
);
20219 case RULE_OP_MANGLE_TOGGLE_AT
:
20220 NEXT_RULEPOS (rule_pos
);
20221 NEXT_RPTOI (rule
, rule_pos
, upos
);
20222 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20225 case RULE_OP_MANGLE_REVERSE
:
20226 out_len
= mangle_reverse (out
, out_len
);
20229 case RULE_OP_MANGLE_DUPEWORD
:
20230 out_len
= mangle_double (out
, out_len
);
20233 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20234 NEXT_RULEPOS (rule_pos
);
20235 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20236 out_len
= mangle_double_times (out
, out_len
, ulen
);
20239 case RULE_OP_MANGLE_REFLECT
:
20240 out_len
= mangle_reflect (out
, out_len
);
20243 case RULE_OP_MANGLE_ROTATE_LEFT
:
20244 mangle_rotate_left (out
, out_len
);
20247 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20248 mangle_rotate_right (out
, out_len
);
20251 case RULE_OP_MANGLE_APPEND
:
20252 NEXT_RULEPOS (rule_pos
);
20253 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20256 case RULE_OP_MANGLE_PREPEND
:
20257 NEXT_RULEPOS (rule_pos
);
20258 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20261 case RULE_OP_MANGLE_DELETE_FIRST
:
20262 out_len
= mangle_delete_at (out
, out_len
, 0);
20265 case RULE_OP_MANGLE_DELETE_LAST
:
20266 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20269 case RULE_OP_MANGLE_DELETE_AT
:
20270 NEXT_RULEPOS (rule_pos
);
20271 NEXT_RPTOI (rule
, rule_pos
, upos
);
20272 out_len
= mangle_delete_at (out
, out_len
, upos
);
20275 case RULE_OP_MANGLE_EXTRACT
:
20276 NEXT_RULEPOS (rule_pos
);
20277 NEXT_RPTOI (rule
, rule_pos
, upos
);
20278 NEXT_RULEPOS (rule_pos
);
20279 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20280 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20283 case RULE_OP_MANGLE_OMIT
:
20284 NEXT_RULEPOS (rule_pos
);
20285 NEXT_RPTOI (rule
, rule_pos
, upos
);
20286 NEXT_RULEPOS (rule_pos
);
20287 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20288 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20291 case RULE_OP_MANGLE_INSERT
:
20292 NEXT_RULEPOS (rule_pos
);
20293 NEXT_RPTOI (rule
, rule_pos
, upos
);
20294 NEXT_RULEPOS (rule_pos
);
20295 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20298 case RULE_OP_MANGLE_OVERSTRIKE
:
20299 NEXT_RULEPOS (rule_pos
);
20300 NEXT_RPTOI (rule
, rule_pos
, upos
);
20301 NEXT_RULEPOS (rule_pos
);
20302 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20305 case RULE_OP_MANGLE_TRUNCATE_AT
:
20306 NEXT_RULEPOS (rule_pos
);
20307 NEXT_RPTOI (rule
, rule_pos
, upos
);
20308 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20311 case RULE_OP_MANGLE_REPLACE
:
20312 NEXT_RULEPOS (rule_pos
);
20313 NEXT_RULEPOS (rule_pos
);
20314 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20317 case RULE_OP_MANGLE_PURGECHAR
:
20318 NEXT_RULEPOS (rule_pos
);
20319 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20322 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20326 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20327 NEXT_RULEPOS (rule_pos
);
20328 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20329 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20332 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20333 NEXT_RULEPOS (rule_pos
);
20334 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20335 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20338 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20339 out_len
= mangle_dupechar (out
, out_len
);
20342 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20343 NEXT_RULEPOS (rule_pos
);
20344 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20345 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20348 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20349 NEXT_RULEPOS (rule_pos
);
20350 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20351 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20354 case RULE_OP_MANGLE_SWITCH_FIRST
:
20355 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20358 case RULE_OP_MANGLE_SWITCH_LAST
:
20359 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20362 case RULE_OP_MANGLE_SWITCH_AT
:
20363 NEXT_RULEPOS (rule_pos
);
20364 NEXT_RPTOI (rule
, rule_pos
, upos
);
20365 NEXT_RULEPOS (rule_pos
);
20366 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20367 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20370 case RULE_OP_MANGLE_CHR_SHIFTL
:
20371 NEXT_RULEPOS (rule_pos
);
20372 NEXT_RPTOI (rule
, rule_pos
, upos
);
20373 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20376 case RULE_OP_MANGLE_CHR_SHIFTR
:
20377 NEXT_RULEPOS (rule_pos
);
20378 NEXT_RPTOI (rule
, rule_pos
, upos
);
20379 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20382 case RULE_OP_MANGLE_CHR_INCR
:
20383 NEXT_RULEPOS (rule_pos
);
20384 NEXT_RPTOI (rule
, rule_pos
, upos
);
20385 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20388 case RULE_OP_MANGLE_CHR_DECR
:
20389 NEXT_RULEPOS (rule_pos
);
20390 NEXT_RPTOI (rule
, rule_pos
, upos
);
20391 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20394 case RULE_OP_MANGLE_REPLACE_NP1
:
20395 NEXT_RULEPOS (rule_pos
);
20396 NEXT_RPTOI (rule
, rule_pos
, upos
);
20397 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20400 case RULE_OP_MANGLE_REPLACE_NM1
:
20401 NEXT_RULEPOS (rule_pos
);
20402 NEXT_RPTOI (rule
, rule_pos
, upos
);
20403 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20406 case RULE_OP_MANGLE_TITLE
:
20407 out_len
= mangle_title (out
, out_len
);
20410 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20411 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20412 NEXT_RULEPOS (rule_pos
);
20413 NEXT_RPTOI (rule
, rule_pos
, upos
);
20414 NEXT_RULEPOS (rule_pos
);
20415 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20416 NEXT_RULEPOS (rule_pos
);
20417 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20418 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20421 case RULE_OP_MANGLE_APPEND_MEMORY
:
20422 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20423 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20424 memcpy (out
+ out_len
, mem
, mem_len
);
20425 out_len
+= mem_len
;
20428 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20429 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20430 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20431 memcpy (mem
+ mem_len
, out
, out_len
);
20432 out_len
+= mem_len
;
20433 memcpy (out
, mem
, out_len
);
20436 case RULE_OP_MEMORIZE_WORD
:
20437 memcpy (mem
, out
, out_len
);
20441 case RULE_OP_REJECT_LESS
:
20442 NEXT_RULEPOS (rule_pos
);
20443 NEXT_RPTOI (rule
, rule_pos
, upos
);
20444 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20447 case RULE_OP_REJECT_GREATER
:
20448 NEXT_RULEPOS (rule_pos
);
20449 NEXT_RPTOI (rule
, rule_pos
, upos
);
20450 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20453 case RULE_OP_REJECT_CONTAIN
:
20454 NEXT_RULEPOS (rule_pos
);
20455 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20458 case RULE_OP_REJECT_NOT_CONTAIN
:
20459 NEXT_RULEPOS (rule_pos
);
20460 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20463 case RULE_OP_REJECT_EQUAL_FIRST
:
20464 NEXT_RULEPOS (rule_pos
);
20465 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20468 case RULE_OP_REJECT_EQUAL_LAST
:
20469 NEXT_RULEPOS (rule_pos
);
20470 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20473 case RULE_OP_REJECT_EQUAL_AT
:
20474 NEXT_RULEPOS (rule_pos
);
20475 NEXT_RPTOI (rule
, rule_pos
, upos
);
20476 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20477 NEXT_RULEPOS (rule_pos
);
20478 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20481 case RULE_OP_REJECT_CONTAINS
:
20482 NEXT_RULEPOS (rule_pos
);
20483 NEXT_RPTOI (rule
, rule_pos
, upos
);
20484 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20485 NEXT_RULEPOS (rule_pos
);
20486 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20487 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20490 case RULE_OP_REJECT_MEMORY
:
20491 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20495 return (RULE_RC_SYNTAX_ERROR
);
20500 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);