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
|= ((uint
) hex_convert (hex
[7])) << 0;
639 v
|= ((uint
) hex_convert (hex
[6])) << 4;
640 v
|= ((uint
) hex_convert (hex
[5])) << 8;
641 v
|= ((uint
) hex_convert (hex
[4])) << 12;
642 v
|= ((uint
) hex_convert (hex
[3])) << 16;
643 v
|= ((uint
) hex_convert (hex
[2])) << 20;
644 v
|= ((uint
) hex_convert (hex
[1])) << 24;
645 v
|= ((uint
) 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 (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 // Do not use CPU by default, this often reduces GPU performance because
5171 // the CPU is to busy to handle GPU synchronization
5173 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5176 return device_types_filter
;
5179 uint
devices_to_devicemask (char *opencl_devices
)
5181 uint opencl_devicemask
= 0;
5185 char *devices
= strdup (opencl_devices
);
5187 char *next
= strtok (devices
, ",");
5191 uint device_id
= atoi (next
);
5193 if (device_id
< 1 || device_id
> 8)
5195 log_error ("ERROR: invalid device_id %u specified", device_id
);
5200 opencl_devicemask
|= 1 << (device_id
- 1);
5202 } while ((next
= strtok (NULL
, ",")) != NULL
);
5207 return opencl_devicemask
;
5210 uint
get_random_num (uint min
, uint max
)
5212 if (min
== max
) return (min
);
5214 return (uint
) ((rand () % (max
- min
)) + min
);
5217 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5219 uint32_t quotient
= dividend
/ divisor
;
5221 if (dividend
% divisor
) quotient
++;
5226 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5228 uint64_t quotient
= dividend
/ divisor
;
5230 if (dividend
% divisor
) quotient
++;
5235 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5237 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5238 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5240 if (tm
->tm_year
- 70)
5242 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5243 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5245 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5247 else if (tm
->tm_yday
)
5249 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5250 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5252 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5254 else if (tm
->tm_hour
)
5256 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5257 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5259 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5261 else if (tm
->tm_min
)
5263 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5264 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5266 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5270 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5272 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5276 void format_speed_display (float val
, char *buf
, size_t len
)
5287 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5298 /* generate output */
5302 snprintf (buf
, len
- 1, "%.0f ", val
);
5306 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5310 void lowercase (char *buf
, int len
)
5312 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5315 void uppercase (char *buf
, int len
)
5317 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5320 int fgetl (FILE *fp
, char *line_buf
)
5326 const int c
= fgetc (fp
);
5328 if (c
== EOF
) break;
5330 line_buf
[line_len
] = (char) c
;
5334 if (line_len
== BUFSIZ
) line_len
--;
5336 if (c
== '\n') break;
5339 if (line_len
== 0) return 0;
5341 if (line_buf
[line_len
- 1] == '\n')
5345 line_buf
[line_len
] = 0;
5348 if (line_len
== 0) return 0;
5350 if (line_buf
[line_len
- 1] == '\r')
5354 line_buf
[line_len
] = 0;
5360 int in_superchop (char *buf
)
5362 int len
= strlen (buf
);
5366 if (buf
[len
- 1] == '\n')
5373 if (buf
[len
- 1] == '\r')
5388 char **scan_directory (const char *path
)
5390 char *tmp_path
= mystrdup (path
);
5392 size_t tmp_path_len
= strlen (tmp_path
);
5394 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5396 tmp_path
[tmp_path_len
- 1] = 0;
5398 tmp_path_len
= strlen (tmp_path
);
5401 char **files
= NULL
;
5407 if ((d
= opendir (tmp_path
)) != NULL
)
5411 while ((de
= readdir (d
)) != NULL
)
5413 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5415 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5417 char *path_file
= (char *) mymalloc (path_size
+ 1);
5419 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5421 path_file
[path_size
] = 0;
5425 if ((d_test
= opendir (path_file
)) != NULL
)
5433 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5437 files
[num_files
- 1] = path_file
;
5443 else if (errno
== ENOTDIR
)
5445 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5449 files
[num_files
- 1] = mystrdup (path
);
5452 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5456 files
[num_files
- 1] = NULL
;
5463 int count_dictionaries (char **dictionary_files
)
5465 if (dictionary_files
== NULL
) return 0;
5469 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5477 char *stroptitype (const uint opti_type
)
5481 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5482 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5483 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5484 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5485 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5486 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5487 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5488 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5489 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5490 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5491 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5492 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5493 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5494 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5500 char *strparser (const uint parser_status
)
5502 switch (parser_status
)
5504 case PARSER_OK
: return ((char *) PA_000
); break;
5505 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5506 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5507 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5508 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5509 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5510 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5511 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5512 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5513 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5514 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5515 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5516 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5517 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5518 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5519 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5520 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5523 return ((char *) PA_255
);
5526 char *strhashtype (const uint hash_mode
)
5530 case 0: return ((char *) HT_00000
); break;
5531 case 10: return ((char *) HT_00010
); break;
5532 case 11: return ((char *) HT_00011
); break;
5533 case 12: return ((char *) HT_00012
); break;
5534 case 20: return ((char *) HT_00020
); break;
5535 case 21: return ((char *) HT_00021
); break;
5536 case 22: return ((char *) HT_00022
); break;
5537 case 23: return ((char *) HT_00023
); break;
5538 case 30: return ((char *) HT_00030
); break;
5539 case 40: return ((char *) HT_00040
); break;
5540 case 50: return ((char *) HT_00050
); break;
5541 case 60: return ((char *) HT_00060
); break;
5542 case 100: return ((char *) HT_00100
); break;
5543 case 101: return ((char *) HT_00101
); break;
5544 case 110: return ((char *) HT_00110
); break;
5545 case 111: return ((char *) HT_00111
); break;
5546 case 112: return ((char *) HT_00112
); break;
5547 case 120: return ((char *) HT_00120
); break;
5548 case 121: return ((char *) HT_00121
); break;
5549 case 122: return ((char *) HT_00122
); break;
5550 case 124: return ((char *) HT_00124
); break;
5551 case 130: return ((char *) HT_00130
); break;
5552 case 131: return ((char *) HT_00131
); break;
5553 case 132: return ((char *) HT_00132
); break;
5554 case 133: return ((char *) HT_00133
); break;
5555 case 140: return ((char *) HT_00140
); break;
5556 case 141: return ((char *) HT_00141
); break;
5557 case 150: return ((char *) HT_00150
); break;
5558 case 160: return ((char *) HT_00160
); break;
5559 case 190: return ((char *) HT_00190
); break;
5560 case 200: return ((char *) HT_00200
); break;
5561 case 300: return ((char *) HT_00300
); break;
5562 case 400: return ((char *) HT_00400
); break;
5563 case 500: return ((char *) HT_00500
); break;
5564 case 501: return ((char *) HT_00501
); break;
5565 case 900: return ((char *) HT_00900
); break;
5566 case 910: return ((char *) HT_00910
); break;
5567 case 1000: return ((char *) HT_01000
); break;
5568 case 1100: return ((char *) HT_01100
); break;
5569 case 1400: return ((char *) HT_01400
); break;
5570 case 1410: return ((char *) HT_01410
); break;
5571 case 1420: return ((char *) HT_01420
); break;
5572 case 1421: return ((char *) HT_01421
); break;
5573 case 1430: return ((char *) HT_01430
); break;
5574 case 1440: return ((char *) HT_01440
); break;
5575 case 1441: return ((char *) HT_01441
); break;
5576 case 1450: return ((char *) HT_01450
); break;
5577 case 1460: return ((char *) HT_01460
); break;
5578 case 1500: return ((char *) HT_01500
); break;
5579 case 1600: return ((char *) HT_01600
); break;
5580 case 1700: return ((char *) HT_01700
); break;
5581 case 1710: return ((char *) HT_01710
); break;
5582 case 1711: return ((char *) HT_01711
); break;
5583 case 1720: return ((char *) HT_01720
); break;
5584 case 1722: return ((char *) HT_01722
); break;
5585 case 1730: return ((char *) HT_01730
); break;
5586 case 1731: return ((char *) HT_01731
); break;
5587 case 1740: return ((char *) HT_01740
); break;
5588 case 1750: return ((char *) HT_01750
); break;
5589 case 1760: return ((char *) HT_01760
); break;
5590 case 1800: return ((char *) HT_01800
); break;
5591 case 2100: return ((char *) HT_02100
); break;
5592 case 2400: return ((char *) HT_02400
); break;
5593 case 2410: return ((char *) HT_02410
); break;
5594 case 2500: return ((char *) HT_02500
); break;
5595 case 2600: return ((char *) HT_02600
); break;
5596 case 2611: return ((char *) HT_02611
); break;
5597 case 2612: return ((char *) HT_02612
); break;
5598 case 2711: return ((char *) HT_02711
); break;
5599 case 2811: return ((char *) HT_02811
); break;
5600 case 3000: return ((char *) HT_03000
); break;
5601 case 3100: return ((char *) HT_03100
); break;
5602 case 3200: return ((char *) HT_03200
); break;
5603 case 3710: return ((char *) HT_03710
); break;
5604 case 3711: return ((char *) HT_03711
); break;
5605 case 3800: return ((char *) HT_03800
); break;
5606 case 4300: return ((char *) HT_04300
); break;
5607 case 4400: return ((char *) HT_04400
); break;
5608 case 4500: return ((char *) HT_04500
); break;
5609 case 4700: return ((char *) HT_04700
); break;
5610 case 4800: return ((char *) HT_04800
); break;
5611 case 4900: return ((char *) HT_04900
); break;
5612 case 5000: return ((char *) HT_05000
); break;
5613 case 5100: return ((char *) HT_05100
); break;
5614 case 5200: return ((char *) HT_05200
); break;
5615 case 5300: return ((char *) HT_05300
); break;
5616 case 5400: return ((char *) HT_05400
); break;
5617 case 5500: return ((char *) HT_05500
); break;
5618 case 5600: return ((char *) HT_05600
); break;
5619 case 5700: return ((char *) HT_05700
); break;
5620 case 5800: return ((char *) HT_05800
); break;
5621 case 6000: return ((char *) HT_06000
); break;
5622 case 6100: return ((char *) HT_06100
); break;
5623 case 6211: return ((char *) HT_06211
); break;
5624 case 6212: return ((char *) HT_06212
); break;
5625 case 6213: return ((char *) HT_06213
); break;
5626 case 6221: return ((char *) HT_06221
); break;
5627 case 6222: return ((char *) HT_06222
); break;
5628 case 6223: return ((char *) HT_06223
); break;
5629 case 6231: return ((char *) HT_06231
); break;
5630 case 6232: return ((char *) HT_06232
); break;
5631 case 6233: return ((char *) HT_06233
); break;
5632 case 6241: return ((char *) HT_06241
); break;
5633 case 6242: return ((char *) HT_06242
); break;
5634 case 6243: return ((char *) HT_06243
); break;
5635 case 6300: return ((char *) HT_06300
); break;
5636 case 6400: return ((char *) HT_06400
); break;
5637 case 6500: return ((char *) HT_06500
); break;
5638 case 6600: return ((char *) HT_06600
); break;
5639 case 6700: return ((char *) HT_06700
); break;
5640 case 6800: return ((char *) HT_06800
); break;
5641 case 6900: return ((char *) HT_06900
); break;
5642 case 7100: return ((char *) HT_07100
); break;
5643 case 7200: return ((char *) HT_07200
); break;
5644 case 7300: return ((char *) HT_07300
); break;
5645 case 7400: return ((char *) HT_07400
); break;
5646 case 7500: return ((char *) HT_07500
); break;
5647 case 7600: return ((char *) HT_07600
); break;
5648 case 7700: return ((char *) HT_07700
); break;
5649 case 7800: return ((char *) HT_07800
); break;
5650 case 7900: return ((char *) HT_07900
); break;
5651 case 8000: return ((char *) HT_08000
); break;
5652 case 8100: return ((char *) HT_08100
); break;
5653 case 8200: return ((char *) HT_08200
); break;
5654 case 8300: return ((char *) HT_08300
); break;
5655 case 8400: return ((char *) HT_08400
); break;
5656 case 8500: return ((char *) HT_08500
); break;
5657 case 8600: return ((char *) HT_08600
); break;
5658 case 8700: return ((char *) HT_08700
); break;
5659 case 8800: return ((char *) HT_08800
); break;
5660 case 8900: return ((char *) HT_08900
); break;
5661 case 9000: return ((char *) HT_09000
); break;
5662 case 9100: return ((char *) HT_09100
); break;
5663 case 9200: return ((char *) HT_09200
); break;
5664 case 9300: return ((char *) HT_09300
); break;
5665 case 9400: return ((char *) HT_09400
); break;
5666 case 9500: return ((char *) HT_09500
); break;
5667 case 9600: return ((char *) HT_09600
); break;
5668 case 9700: return ((char *) HT_09700
); break;
5669 case 9710: return ((char *) HT_09710
); break;
5670 case 9720: return ((char *) HT_09720
); break;
5671 case 9800: return ((char *) HT_09800
); break;
5672 case 9810: return ((char *) HT_09810
); break;
5673 case 9820: return ((char *) HT_09820
); break;
5674 case 9900: return ((char *) HT_09900
); break;
5675 case 10000: return ((char *) HT_10000
); break;
5676 case 10100: return ((char *) HT_10100
); break;
5677 case 10200: return ((char *) HT_10200
); break;
5678 case 10300: return ((char *) HT_10300
); break;
5679 case 10400: return ((char *) HT_10400
); break;
5680 case 10410: return ((char *) HT_10410
); break;
5681 case 10420: return ((char *) HT_10420
); break;
5682 case 10500: return ((char *) HT_10500
); break;
5683 case 10600: return ((char *) HT_10600
); break;
5684 case 10700: return ((char *) HT_10700
); break;
5685 case 10800: return ((char *) HT_10800
); break;
5686 case 10900: return ((char *) HT_10900
); break;
5687 case 11000: return ((char *) HT_11000
); break;
5688 case 11100: return ((char *) HT_11100
); break;
5689 case 11200: return ((char *) HT_11200
); break;
5690 case 11300: return ((char *) HT_11300
); break;
5691 case 11400: return ((char *) HT_11400
); break;
5692 case 11500: return ((char *) HT_11500
); break;
5693 case 11600: return ((char *) HT_11600
); break;
5694 case 11700: return ((char *) HT_11700
); break;
5695 case 11800: return ((char *) HT_11800
); break;
5696 case 11900: return ((char *) HT_11900
); break;
5697 case 12000: return ((char *) HT_12000
); break;
5698 case 12100: return ((char *) HT_12100
); break;
5699 case 12200: return ((char *) HT_12200
); break;
5700 case 12300: return ((char *) HT_12300
); break;
5701 case 12400: return ((char *) HT_12400
); break;
5702 case 12500: return ((char *) HT_12500
); break;
5703 case 12600: return ((char *) HT_12600
); break;
5704 case 12700: return ((char *) HT_12700
); break;
5705 case 12800: return ((char *) HT_12800
); break;
5706 case 12900: return ((char *) HT_12900
); break;
5707 case 13000: return ((char *) HT_13000
); break;
5710 return ((char *) "Unknown");
5713 char *strstatus (const uint devices_status
)
5715 switch (devices_status
)
5717 case STATUS_INIT
: return ((char *) ST_0000
); break;
5718 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5719 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5720 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5721 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5722 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5723 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5724 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5725 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5726 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5729 return ((char *) "Unknown");
5732 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5734 uint hash_type
= data
.hash_type
;
5735 uint hash_mode
= data
.hash_mode
;
5736 uint salt_type
= data
.salt_type
;
5737 uint opts_type
= data
.opts_type
;
5738 uint opti_type
= data
.opti_type
;
5739 uint dgst_size
= data
.dgst_size
;
5741 char *hashfile
= data
.hashfile
;
5745 uint digest_buf
[64];
5747 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5749 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5751 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5753 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5759 case HASH_TYPE_DESCRYPT
:
5760 FP (digest_buf
[1], digest_buf
[0], tt
);
5763 case HASH_TYPE_DESRACF
:
5764 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5765 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5767 FP (digest_buf
[1], digest_buf
[0], tt
);
5771 FP (digest_buf
[1], digest_buf
[0], tt
);
5774 case HASH_TYPE_NETNTLM
:
5775 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5776 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5777 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5778 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5780 FP (digest_buf
[1], digest_buf
[0], tt
);
5781 FP (digest_buf
[3], digest_buf
[2], tt
);
5784 case HASH_TYPE_BSDICRYPT
:
5785 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5786 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5788 FP (digest_buf
[1], digest_buf
[0], tt
);
5793 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5798 digest_buf
[0] += MD4M_A
;
5799 digest_buf
[1] += MD4M_B
;
5800 digest_buf
[2] += MD4M_C
;
5801 digest_buf
[3] += MD4M_D
;
5805 digest_buf
[0] += MD5M_A
;
5806 digest_buf
[1] += MD5M_B
;
5807 digest_buf
[2] += MD5M_C
;
5808 digest_buf
[3] += MD5M_D
;
5811 case HASH_TYPE_SHA1
:
5812 digest_buf
[0] += SHA1M_A
;
5813 digest_buf
[1] += SHA1M_B
;
5814 digest_buf
[2] += SHA1M_C
;
5815 digest_buf
[3] += SHA1M_D
;
5816 digest_buf
[4] += SHA1M_E
;
5819 case HASH_TYPE_SHA256
:
5820 digest_buf
[0] += SHA256M_A
;
5821 digest_buf
[1] += SHA256M_B
;
5822 digest_buf
[2] += SHA256M_C
;
5823 digest_buf
[3] += SHA256M_D
;
5824 digest_buf
[4] += SHA256M_E
;
5825 digest_buf
[5] += SHA256M_F
;
5826 digest_buf
[6] += SHA256M_G
;
5827 digest_buf
[7] += SHA256M_H
;
5830 case HASH_TYPE_SHA384
:
5831 digest_buf64
[0] += SHA384M_A
;
5832 digest_buf64
[1] += SHA384M_B
;
5833 digest_buf64
[2] += SHA384M_C
;
5834 digest_buf64
[3] += SHA384M_D
;
5835 digest_buf64
[4] += SHA384M_E
;
5836 digest_buf64
[5] += SHA384M_F
;
5837 digest_buf64
[6] += 0;
5838 digest_buf64
[7] += 0;
5841 case HASH_TYPE_SHA512
:
5842 digest_buf64
[0] += SHA512M_A
;
5843 digest_buf64
[1] += SHA512M_B
;
5844 digest_buf64
[2] += SHA512M_C
;
5845 digest_buf64
[3] += SHA512M_D
;
5846 digest_buf64
[4] += SHA512M_E
;
5847 digest_buf64
[5] += SHA512M_F
;
5848 digest_buf64
[6] += SHA512M_G
;
5849 digest_buf64
[7] += SHA512M_H
;
5854 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5856 if (dgst_size
== DGST_SIZE_4_2
)
5858 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5860 else if (dgst_size
== DGST_SIZE_4_4
)
5862 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5864 else if (dgst_size
== DGST_SIZE_4_5
)
5866 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5868 else if (dgst_size
== DGST_SIZE_4_6
)
5870 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5872 else if (dgst_size
== DGST_SIZE_4_8
)
5874 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5876 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5878 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5880 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5882 else if (hash_type
== HASH_TYPE_SHA384
)
5884 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5886 else if (hash_type
== HASH_TYPE_SHA512
)
5888 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5890 else if (hash_type
== HASH_TYPE_GOST
)
5892 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5895 else if (dgst_size
== DGST_SIZE_4_64
)
5897 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5899 else if (dgst_size
== DGST_SIZE_8_25
)
5901 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5905 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5906 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5907 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5913 memset (&salt
, 0, sizeof (salt_t
));
5915 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5917 char *ptr
= (char *) salt
.salt_buf
;
5919 uint len
= salt
.salt_len
;
5921 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5927 case HASH_TYPE_NETNTLM
:
5929 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5930 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5932 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5938 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5940 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5948 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5950 uint max
= salt
.salt_len
/ 4;
5954 for (uint i
= 0; i
< max
; i
++)
5956 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5960 if (opts_type
& OPTS_TYPE_ST_HEX
)
5964 memset (tmp
, 0, sizeof (tmp
));
5966 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5968 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5973 memcpy (ptr
, tmp
, len
);
5976 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5978 memset (ptr
+ len
, 0, memset_size
);
5980 salt
.salt_len
= len
;
5984 // some modes require special encoding
5987 uint out_buf_plain
[256];
5988 uint out_buf_salt
[256];
5992 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5993 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5995 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5997 char *ptr_plain
= (char *) out_buf_plain
;
5998 char *ptr_salt
= (char *) out_buf_salt
;
6000 if (hash_mode
== 22)
6004 memset (username
, 0, sizeof (username
));
6006 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6008 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6010 uint16_t *ptr
= (uint16_t *) digest_buf
;
6012 tmp_buf
[ 0] = sig
[0];
6013 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6014 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6015 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6016 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6017 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6018 tmp_buf
[ 6] = sig
[1];
6019 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6020 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6021 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6022 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6023 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6024 tmp_buf
[12] = sig
[2];
6025 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6026 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6027 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6028 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6029 tmp_buf
[17] = sig
[3];
6030 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6031 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6032 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6033 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6034 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6035 tmp_buf
[23] = sig
[4];
6036 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6037 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6038 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6039 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6040 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6041 tmp_buf
[29] = sig
[5];
6043 snprintf (out_buf
, len
-1, "%s:%s",
6047 else if (hash_mode
== 23)
6049 // do not show the \nskyper\n part in output
6051 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6053 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6055 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6062 else if (hash_mode
== 101)
6064 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6066 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6067 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6068 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6069 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6070 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6072 memcpy (tmp_buf
, digest_buf
, 20);
6074 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6076 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6078 else if (hash_mode
== 111)
6080 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6082 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6083 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6084 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6085 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6086 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6088 memcpy (tmp_buf
, digest_buf
, 20);
6089 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6091 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
6093 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6095 else if (hash_mode
== 122)
6097 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6098 (unsigned char *) salt
.salt_buf
,
6105 else if (hash_mode
== 124)
6107 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6108 (unsigned char *) salt
.salt_buf
,
6115 else if (hash_mode
== 131)
6117 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6118 (unsigned char *) salt
.salt_buf
,
6126 else if (hash_mode
== 132)
6128 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6129 (unsigned char *) salt
.salt_buf
,
6136 else if (hash_mode
== 133)
6138 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6140 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6141 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6142 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6143 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6144 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6146 memcpy (tmp_buf
, digest_buf
, 20);
6148 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6150 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6152 else if (hash_mode
== 141)
6154 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6156 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6158 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6160 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6162 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6163 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6164 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6165 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6166 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6168 memcpy (tmp_buf
, digest_buf
, 20);
6170 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6174 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6176 else if (hash_mode
== 400)
6178 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6180 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6181 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6182 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6183 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6185 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6187 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6189 else if (hash_mode
== 500)
6191 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6193 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6194 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6195 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6196 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6198 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6200 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6202 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6206 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6209 else if (hash_mode
== 501)
6211 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6213 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6214 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6216 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6218 else if (hash_mode
== 1421)
6220 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6222 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6238 else if (hash_mode
== 1441)
6240 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6242 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6244 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6246 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6248 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6249 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6250 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6251 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6252 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6253 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6254 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6255 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6257 memcpy (tmp_buf
, digest_buf
, 32);
6259 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6263 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6265 else if (hash_mode
== 1500)
6267 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6268 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6269 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6270 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6271 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6273 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6275 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6277 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6278 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6280 memcpy (tmp_buf
, digest_buf
, 8);
6282 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6284 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6288 else if (hash_mode
== 1600)
6290 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6292 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6293 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6294 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6295 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6297 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6299 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6301 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6305 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6308 else if (hash_mode
== 1711)
6310 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6312 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6313 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6314 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6315 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6316 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6317 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6318 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6319 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6321 memcpy (tmp_buf
, digest_buf
, 64);
6322 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6324 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6326 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6328 else if (hash_mode
== 1722)
6330 uint
*ptr
= digest_buf
;
6332 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6333 (unsigned char *) salt
.salt_buf
,
6343 else if (hash_mode
== 1731)
6345 uint
*ptr
= digest_buf
;
6347 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6348 (unsigned char *) salt
.salt_buf
,
6358 else if (hash_mode
== 1800)
6362 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6363 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6364 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6365 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6366 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6367 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6368 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6369 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6371 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6373 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6375 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6379 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6382 else if (hash_mode
== 2100)
6386 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6388 salt
.salt_iter
+ 1);
6390 uint signature_len
= strlen (out_buf
);
6392 pos
+= signature_len
;
6393 len
-= signature_len
;
6395 char *salt_ptr
= (char *) salt
.salt_buf
;
6397 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6399 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6400 byte_swap_32 (digest_buf
[0]),
6401 byte_swap_32 (digest_buf
[1]),
6402 byte_swap_32 (digest_buf
[2]),
6403 byte_swap_32 (digest_buf
[3]));
6405 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6407 memcpy (tmp_buf
, digest_buf
, 16);
6409 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6411 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6412 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6413 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6414 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6416 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6417 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6418 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6419 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6421 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6422 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6423 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6424 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6426 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6427 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6428 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6429 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6431 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6432 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6433 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6434 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6438 else if (hash_mode
== 2500)
6440 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6442 wpa_t
*wpa
= &wpas
[salt_pos
];
6446 char *pke_ptr
= (char *) pke
;
6448 for (uint i
= 0; i
< 25; i
++)
6450 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6453 unsigned char mac1
[6];
6454 unsigned char mac2
[6];
6456 memcpy (mac1
, pke_ptr
+ 23, 6);
6457 memcpy (mac2
, pke_ptr
+ 29, 6);
6459 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6460 (char *) salt
.salt_buf
,
6474 else if (hash_mode
== 4400)
6476 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6477 byte_swap_32 (digest_buf
[0]),
6478 byte_swap_32 (digest_buf
[1]),
6479 byte_swap_32 (digest_buf
[2]),
6480 byte_swap_32 (digest_buf
[3]));
6482 else if (hash_mode
== 4700)
6484 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6485 byte_swap_32 (digest_buf
[0]),
6486 byte_swap_32 (digest_buf
[1]),
6487 byte_swap_32 (digest_buf
[2]),
6488 byte_swap_32 (digest_buf
[3]),
6489 byte_swap_32 (digest_buf
[4]));
6491 else if (hash_mode
== 4800)
6493 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6495 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6500 byte_swap_32 (salt
.salt_buf
[0]),
6501 byte_swap_32 (salt
.salt_buf
[1]),
6502 byte_swap_32 (salt
.salt_buf
[2]),
6503 byte_swap_32 (salt
.salt_buf
[3]),
6506 else if (hash_mode
== 4900)
6508 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6509 byte_swap_32 (digest_buf
[0]),
6510 byte_swap_32 (digest_buf
[1]),
6511 byte_swap_32 (digest_buf
[2]),
6512 byte_swap_32 (digest_buf
[3]),
6513 byte_swap_32 (digest_buf
[4]));
6515 else if (hash_mode
== 5100)
6517 snprintf (out_buf
, len
-1, "%08x%08x",
6521 else if (hash_mode
== 5200)
6523 snprintf (out_buf
, len
-1, "%s", hashfile
);
6525 else if (hash_mode
== 5300)
6527 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6529 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6531 int buf_len
= len
-1;
6535 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6537 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6539 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6541 snprintf (out_buf
, buf_len
, ":");
6547 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6555 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6557 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6559 if ((i
== 0) || (i
== 5))
6561 snprintf (out_buf
, buf_len
, ":");
6567 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6575 for (uint i
= 0; i
< 4; i
++)
6579 snprintf (out_buf
, buf_len
, ":");
6585 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6591 else if (hash_mode
== 5400)
6593 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6595 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6597 int buf_len
= len
-1;
6601 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6603 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6605 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6607 snprintf (out_buf
, buf_len
, ":");
6613 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6621 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6623 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6625 if ((i
== 0) || (i
== 5))
6627 snprintf (out_buf
, buf_len
, ":");
6633 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6641 for (uint i
= 0; i
< 5; i
++)
6645 snprintf (out_buf
, buf_len
, ":");
6651 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6657 else if (hash_mode
== 5500)
6659 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6661 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6664 char domain_buf
[64];
6665 char srvchall_buf
[1024];
6666 char clichall_buf
[1024];
6668 memset (user_buf
, 0, sizeof (user_buf
));
6669 memset (domain_buf
, 0, sizeof (domain_buf
));
6670 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6671 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6673 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6675 char *ptr
= (char *) netntlm
->userdomain_buf
;
6677 user_buf
[i
] = ptr
[j
];
6680 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6682 char *ptr
= (char *) netntlm
->userdomain_buf
;
6684 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6687 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6689 char *ptr
= (char *) netntlm
->chall_buf
;
6691 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6694 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6696 char *ptr
= (char *) netntlm
->chall_buf
;
6698 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6701 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6709 byte_swap_32 (salt
.salt_buf_pc
[0]),
6710 byte_swap_32 (salt
.salt_buf_pc
[1]),
6713 else if (hash_mode
== 5600)
6715 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6717 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6720 char domain_buf
[64];
6721 char srvchall_buf
[1024];
6722 char clichall_buf
[1024];
6724 memset (user_buf
, 0, sizeof (user_buf
));
6725 memset (domain_buf
, 0, sizeof (domain_buf
));
6726 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6727 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6729 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6731 char *ptr
= (char *) netntlm
->userdomain_buf
;
6733 user_buf
[i
] = ptr
[j
];
6736 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6738 char *ptr
= (char *) netntlm
->userdomain_buf
;
6740 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6743 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6745 char *ptr
= (char *) netntlm
->chall_buf
;
6747 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6750 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6752 char *ptr
= (char *) netntlm
->chall_buf
;
6754 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6757 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6767 else if (hash_mode
== 5700)
6769 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6771 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6772 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6773 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6774 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6775 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6776 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6777 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6778 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6780 memcpy (tmp_buf
, digest_buf
, 32);
6782 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6786 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6788 else if (hash_mode
== 5800)
6790 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6791 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6792 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6793 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6794 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6796 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6803 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6805 snprintf (out_buf
, len
-1, "%s", hashfile
);
6807 else if (hash_mode
== 6300)
6809 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6811 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6812 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6813 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6814 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6816 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6818 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6820 else if (hash_mode
== 6400)
6822 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6824 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6826 else if (hash_mode
== 6500)
6828 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6830 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6832 else if (hash_mode
== 6600)
6834 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6836 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6838 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6839 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6841 uint buf_len
= len
- 1;
6843 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6846 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6848 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6853 else if (hash_mode
== 6700)
6855 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6857 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6859 else if (hash_mode
== 6800)
6861 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6863 else if (hash_mode
== 7100)
6865 uint
*ptr
= digest_buf
;
6867 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6869 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6873 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6874 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6875 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6876 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6877 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6878 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6879 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6880 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6882 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",
6883 SIGNATURE_SHA512OSX
,
6885 esalt
[ 0], esalt
[ 1],
6886 esalt
[ 2], esalt
[ 3],
6887 esalt
[ 4], esalt
[ 5],
6888 esalt
[ 6], esalt
[ 7],
6896 ptr
[15], ptr
[14]);
6898 else if (hash_mode
== 7200)
6900 uint
*ptr
= digest_buf
;
6902 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6904 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6908 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6910 len_used
= strlen (out_buf
);
6912 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6914 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6916 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6919 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",
6927 ptr
[15], ptr
[14]);
6929 else if (hash_mode
== 7300)
6931 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6933 rakp_t
*rakp
= &rakps
[salt_pos
];
6935 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6937 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6940 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6947 else if (hash_mode
== 7400)
6949 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6951 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6952 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6953 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6954 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6955 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6956 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6957 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6958 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6960 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6962 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6964 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6968 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6971 else if (hash_mode
== 7500)
6973 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6975 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6977 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6978 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6982 char *ptr_data
= data
;
6984 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6986 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6989 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6991 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6996 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6998 (char *) krb5pa
->user
,
6999 (char *) krb5pa
->realm
,
7000 (char *) krb5pa
->salt
,
7003 else if (hash_mode
== 7700)
7005 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7006 (char *) salt
.salt_buf
,
7010 else if (hash_mode
== 7800)
7012 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7013 (char *) salt
.salt_buf
,
7020 else if (hash_mode
== 7900)
7022 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7026 char *tmp
= (char *) salt
.salt_buf_pc
;
7028 ptr_plain
[42] = tmp
[0];
7034 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7036 else if (hash_mode
== 8000)
7038 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7039 (unsigned char *) salt
.salt_buf
,
7049 else if (hash_mode
== 8100)
7051 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7052 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7054 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7055 (unsigned char *) salt
.salt_buf
,
7062 else if (hash_mode
== 8200)
7064 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7066 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7068 char data_buf
[4096];
7070 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7072 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7075 data_buf
[cloudkey
->data_len
* 2] = 0;
7077 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7078 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7079 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7080 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7081 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7082 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7083 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7084 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7086 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7087 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7088 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7089 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7091 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7107 else if (hash_mode
== 8300)
7111 char digest_buf_c
[33];
7113 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
7115 digest_buf_c
[32] = 0;
7119 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7121 char domain_buf_c
[33];
7123 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7125 for (uint i
= 0; i
< salt_pc_len
; i
++)
7127 const char next
= domain_buf_c
[i
];
7129 domain_buf_c
[i
] = '.';
7134 domain_buf_c
[salt_pc_len
] = 0;
7138 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7140 else if (hash_mode
== 8500)
7142 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7144 else if (hash_mode
== 2612)
7146 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7148 (char *) salt
.salt_buf
,
7154 else if (hash_mode
== 3711)
7156 char *salt_ptr
= (char *) salt
.salt_buf
;
7158 salt_ptr
[salt
.salt_len
- 1] = 0;
7160 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7161 SIGNATURE_MEDIAWIKI_B
,
7168 else if (hash_mode
== 8800)
7170 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7172 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7176 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7178 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7183 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7184 SIGNATURE_ANDROIDFDE
,
7185 byte_swap_32 (salt
.salt_buf
[0]),
7186 byte_swap_32 (salt
.salt_buf
[1]),
7187 byte_swap_32 (salt
.salt_buf
[2]),
7188 byte_swap_32 (salt
.salt_buf
[3]),
7189 byte_swap_32 (digest_buf
[0]),
7190 byte_swap_32 (digest_buf
[1]),
7191 byte_swap_32 (digest_buf
[2]),
7192 byte_swap_32 (digest_buf
[3]),
7195 else if (hash_mode
== 8900)
7197 uint N
= salt
.scrypt_N
;
7198 uint r
= salt
.scrypt_r
;
7199 uint p
= salt
.scrypt_p
;
7201 char base64_salt
[32];
7203 memset (base64_salt
, 0, 32);
7205 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7207 memset (tmp_buf
, 0, 46);
7209 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7210 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7211 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7212 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7213 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7214 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7215 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7216 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7217 digest_buf
[8] = 0; // needed for base64_encode ()
7219 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7221 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7229 else if (hash_mode
== 9000)
7231 snprintf (out_buf
, len
-1, "%s", hashfile
);
7233 else if (hash_mode
== 9200)
7237 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7239 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7241 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7245 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7246 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7247 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7248 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7249 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7250 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7251 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7252 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7253 digest_buf
[8] = 0; // needed for base64_encode ()
7256 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7258 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7259 tmp_buf
[43] = 0; // cut it here
7263 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7265 else if (hash_mode
== 9300)
7267 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7268 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7269 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7270 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7271 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7272 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7273 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7274 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7275 digest_buf
[8] = 0; // needed for base64_encode ()
7278 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7280 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7281 tmp_buf
[43] = 0; // cut it here
7283 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7285 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7287 else if (hash_mode
== 9400)
7289 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7291 office2007_t
*office2007
= &office2007s
[salt_pos
];
7293 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7294 SIGNATURE_OFFICE2007
,
7297 office2007
->keySize
,
7303 office2007
->encryptedVerifier
[0],
7304 office2007
->encryptedVerifier
[1],
7305 office2007
->encryptedVerifier
[2],
7306 office2007
->encryptedVerifier
[3],
7307 office2007
->encryptedVerifierHash
[0],
7308 office2007
->encryptedVerifierHash
[1],
7309 office2007
->encryptedVerifierHash
[2],
7310 office2007
->encryptedVerifierHash
[3],
7311 office2007
->encryptedVerifierHash
[4]);
7313 else if (hash_mode
== 9500)
7315 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7317 office2010_t
*office2010
= &office2010s
[salt_pos
];
7319 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,
7325 office2010
->encryptedVerifier
[0],
7326 office2010
->encryptedVerifier
[1],
7327 office2010
->encryptedVerifier
[2],
7328 office2010
->encryptedVerifier
[3],
7329 office2010
->encryptedVerifierHash
[0],
7330 office2010
->encryptedVerifierHash
[1],
7331 office2010
->encryptedVerifierHash
[2],
7332 office2010
->encryptedVerifierHash
[3],
7333 office2010
->encryptedVerifierHash
[4],
7334 office2010
->encryptedVerifierHash
[5],
7335 office2010
->encryptedVerifierHash
[6],
7336 office2010
->encryptedVerifierHash
[7]);
7338 else if (hash_mode
== 9600)
7340 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7342 office2013_t
*office2013
= &office2013s
[salt_pos
];
7344 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,
7350 office2013
->encryptedVerifier
[0],
7351 office2013
->encryptedVerifier
[1],
7352 office2013
->encryptedVerifier
[2],
7353 office2013
->encryptedVerifier
[3],
7354 office2013
->encryptedVerifierHash
[0],
7355 office2013
->encryptedVerifierHash
[1],
7356 office2013
->encryptedVerifierHash
[2],
7357 office2013
->encryptedVerifierHash
[3],
7358 office2013
->encryptedVerifierHash
[4],
7359 office2013
->encryptedVerifierHash
[5],
7360 office2013
->encryptedVerifierHash
[6],
7361 office2013
->encryptedVerifierHash
[7]);
7363 else if (hash_mode
== 9700)
7365 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7367 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7369 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7370 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7371 byte_swap_32 (salt
.salt_buf
[0]),
7372 byte_swap_32 (salt
.salt_buf
[1]),
7373 byte_swap_32 (salt
.salt_buf
[2]),
7374 byte_swap_32 (salt
.salt_buf
[3]),
7375 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7376 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7377 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7378 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7379 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7380 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7381 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7382 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7384 else if (hash_mode
== 9710)
7386 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7388 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7390 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7391 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7392 byte_swap_32 (salt
.salt_buf
[0]),
7393 byte_swap_32 (salt
.salt_buf
[1]),
7394 byte_swap_32 (salt
.salt_buf
[2]),
7395 byte_swap_32 (salt
.salt_buf
[3]),
7396 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7397 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7398 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7399 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7400 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7401 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7402 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7403 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7405 else if (hash_mode
== 9720)
7407 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7409 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7411 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7413 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7414 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7415 byte_swap_32 (salt
.salt_buf
[0]),
7416 byte_swap_32 (salt
.salt_buf
[1]),
7417 byte_swap_32 (salt
.salt_buf
[2]),
7418 byte_swap_32 (salt
.salt_buf
[3]),
7419 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7420 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7421 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7422 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7423 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7424 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7425 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7426 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7433 else if (hash_mode
== 9800)
7435 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7437 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7439 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7440 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7445 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7446 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7447 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7448 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7449 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7450 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7451 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7452 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7453 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7455 else if (hash_mode
== 9810)
7457 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7459 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7461 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7462 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7467 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7468 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7469 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7470 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7471 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7472 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7473 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7474 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7475 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7477 else if (hash_mode
== 9820)
7479 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7481 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7483 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7485 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7486 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7491 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7492 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7493 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7494 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7495 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7496 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7497 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7498 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7499 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7506 else if (hash_mode
== 10000)
7510 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7512 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7514 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7518 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7519 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7520 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7521 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7522 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7523 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7524 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7525 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7526 digest_buf
[8] = 0; // needed for base64_encode ()
7529 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7531 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7535 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7537 else if (hash_mode
== 10100)
7539 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7544 byte_swap_32 (salt
.salt_buf
[0]),
7545 byte_swap_32 (salt
.salt_buf
[1]),
7546 byte_swap_32 (salt
.salt_buf
[2]),
7547 byte_swap_32 (salt
.salt_buf
[3]));
7549 else if (hash_mode
== 10200)
7551 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7553 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7557 char challenge
[100];
7559 memset (challenge
, 0, sizeof (challenge
));
7561 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7567 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7568 (char *) cram_md5
->user
,
7576 memset (response
, 0, sizeof (response
));
7578 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7580 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7582 else if (hash_mode
== 10300)
7586 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7588 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7589 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7591 uint tmp_len
= 20 + salt
.salt_len
;
7595 char base64_encoded
[100];
7597 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7599 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7601 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7603 else if (hash_mode
== 10400)
7605 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7607 pdf_t
*pdf
= &pdfs
[salt_pos
];
7609 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",
7617 byte_swap_32 (pdf
->id_buf
[0]),
7618 byte_swap_32 (pdf
->id_buf
[1]),
7619 byte_swap_32 (pdf
->id_buf
[2]),
7620 byte_swap_32 (pdf
->id_buf
[3]),
7622 byte_swap_32 (pdf
->u_buf
[0]),
7623 byte_swap_32 (pdf
->u_buf
[1]),
7624 byte_swap_32 (pdf
->u_buf
[2]),
7625 byte_swap_32 (pdf
->u_buf
[3]),
7626 byte_swap_32 (pdf
->u_buf
[4]),
7627 byte_swap_32 (pdf
->u_buf
[5]),
7628 byte_swap_32 (pdf
->u_buf
[6]),
7629 byte_swap_32 (pdf
->u_buf
[7]),
7631 byte_swap_32 (pdf
->o_buf
[0]),
7632 byte_swap_32 (pdf
->o_buf
[1]),
7633 byte_swap_32 (pdf
->o_buf
[2]),
7634 byte_swap_32 (pdf
->o_buf
[3]),
7635 byte_swap_32 (pdf
->o_buf
[4]),
7636 byte_swap_32 (pdf
->o_buf
[5]),
7637 byte_swap_32 (pdf
->o_buf
[6]),
7638 byte_swap_32 (pdf
->o_buf
[7])
7641 else if (hash_mode
== 10410)
7643 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7645 pdf_t
*pdf
= &pdfs
[salt_pos
];
7647 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",
7655 byte_swap_32 (pdf
->id_buf
[0]),
7656 byte_swap_32 (pdf
->id_buf
[1]),
7657 byte_swap_32 (pdf
->id_buf
[2]),
7658 byte_swap_32 (pdf
->id_buf
[3]),
7660 byte_swap_32 (pdf
->u_buf
[0]),
7661 byte_swap_32 (pdf
->u_buf
[1]),
7662 byte_swap_32 (pdf
->u_buf
[2]),
7663 byte_swap_32 (pdf
->u_buf
[3]),
7664 byte_swap_32 (pdf
->u_buf
[4]),
7665 byte_swap_32 (pdf
->u_buf
[5]),
7666 byte_swap_32 (pdf
->u_buf
[6]),
7667 byte_swap_32 (pdf
->u_buf
[7]),
7669 byte_swap_32 (pdf
->o_buf
[0]),
7670 byte_swap_32 (pdf
->o_buf
[1]),
7671 byte_swap_32 (pdf
->o_buf
[2]),
7672 byte_swap_32 (pdf
->o_buf
[3]),
7673 byte_swap_32 (pdf
->o_buf
[4]),
7674 byte_swap_32 (pdf
->o_buf
[5]),
7675 byte_swap_32 (pdf
->o_buf
[6]),
7676 byte_swap_32 (pdf
->o_buf
[7])
7679 else if (hash_mode
== 10420)
7681 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7683 pdf_t
*pdf
= &pdfs
[salt_pos
];
7685 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7687 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",
7695 byte_swap_32 (pdf
->id_buf
[0]),
7696 byte_swap_32 (pdf
->id_buf
[1]),
7697 byte_swap_32 (pdf
->id_buf
[2]),
7698 byte_swap_32 (pdf
->id_buf
[3]),
7700 byte_swap_32 (pdf
->u_buf
[0]),
7701 byte_swap_32 (pdf
->u_buf
[1]),
7702 byte_swap_32 (pdf
->u_buf
[2]),
7703 byte_swap_32 (pdf
->u_buf
[3]),
7704 byte_swap_32 (pdf
->u_buf
[4]),
7705 byte_swap_32 (pdf
->u_buf
[5]),
7706 byte_swap_32 (pdf
->u_buf
[6]),
7707 byte_swap_32 (pdf
->u_buf
[7]),
7709 byte_swap_32 (pdf
->o_buf
[0]),
7710 byte_swap_32 (pdf
->o_buf
[1]),
7711 byte_swap_32 (pdf
->o_buf
[2]),
7712 byte_swap_32 (pdf
->o_buf
[3]),
7713 byte_swap_32 (pdf
->o_buf
[4]),
7714 byte_swap_32 (pdf
->o_buf
[5]),
7715 byte_swap_32 (pdf
->o_buf
[6]),
7716 byte_swap_32 (pdf
->o_buf
[7]),
7724 else if (hash_mode
== 10500)
7726 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7728 pdf_t
*pdf
= &pdfs
[salt_pos
];
7730 if (pdf
->id_len
== 32)
7732 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",
7740 byte_swap_32 (pdf
->id_buf
[0]),
7741 byte_swap_32 (pdf
->id_buf
[1]),
7742 byte_swap_32 (pdf
->id_buf
[2]),
7743 byte_swap_32 (pdf
->id_buf
[3]),
7744 byte_swap_32 (pdf
->id_buf
[4]),
7745 byte_swap_32 (pdf
->id_buf
[5]),
7746 byte_swap_32 (pdf
->id_buf
[6]),
7747 byte_swap_32 (pdf
->id_buf
[7]),
7749 byte_swap_32 (pdf
->u_buf
[0]),
7750 byte_swap_32 (pdf
->u_buf
[1]),
7751 byte_swap_32 (pdf
->u_buf
[2]),
7752 byte_swap_32 (pdf
->u_buf
[3]),
7753 byte_swap_32 (pdf
->u_buf
[4]),
7754 byte_swap_32 (pdf
->u_buf
[5]),
7755 byte_swap_32 (pdf
->u_buf
[6]),
7756 byte_swap_32 (pdf
->u_buf
[7]),
7758 byte_swap_32 (pdf
->o_buf
[0]),
7759 byte_swap_32 (pdf
->o_buf
[1]),
7760 byte_swap_32 (pdf
->o_buf
[2]),
7761 byte_swap_32 (pdf
->o_buf
[3]),
7762 byte_swap_32 (pdf
->o_buf
[4]),
7763 byte_swap_32 (pdf
->o_buf
[5]),
7764 byte_swap_32 (pdf
->o_buf
[6]),
7765 byte_swap_32 (pdf
->o_buf
[7])
7770 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",
7778 byte_swap_32 (pdf
->id_buf
[0]),
7779 byte_swap_32 (pdf
->id_buf
[1]),
7780 byte_swap_32 (pdf
->id_buf
[2]),
7781 byte_swap_32 (pdf
->id_buf
[3]),
7783 byte_swap_32 (pdf
->u_buf
[0]),
7784 byte_swap_32 (pdf
->u_buf
[1]),
7785 byte_swap_32 (pdf
->u_buf
[2]),
7786 byte_swap_32 (pdf
->u_buf
[3]),
7787 byte_swap_32 (pdf
->u_buf
[4]),
7788 byte_swap_32 (pdf
->u_buf
[5]),
7789 byte_swap_32 (pdf
->u_buf
[6]),
7790 byte_swap_32 (pdf
->u_buf
[7]),
7792 byte_swap_32 (pdf
->o_buf
[0]),
7793 byte_swap_32 (pdf
->o_buf
[1]),
7794 byte_swap_32 (pdf
->o_buf
[2]),
7795 byte_swap_32 (pdf
->o_buf
[3]),
7796 byte_swap_32 (pdf
->o_buf
[4]),
7797 byte_swap_32 (pdf
->o_buf
[5]),
7798 byte_swap_32 (pdf
->o_buf
[6]),
7799 byte_swap_32 (pdf
->o_buf
[7])
7803 else if (hash_mode
== 10600)
7805 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7807 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7808 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7810 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7812 else if (hash_mode
== 10700)
7814 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7816 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7817 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7819 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7821 else if (hash_mode
== 10900)
7823 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7825 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7826 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7828 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7830 else if (hash_mode
== 11100)
7832 uint32_t salt_challenge
= salt
.salt_buf
[0];
7834 salt_challenge
= byte_swap_32 (salt_challenge
);
7836 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7838 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7839 SIGNATURE_POSTGRESQL_AUTH
,
7847 else if (hash_mode
== 11200)
7849 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7850 SIGNATURE_MYSQL_AUTH
,
7851 (unsigned char *) salt
.salt_buf
,
7858 else if (hash_mode
== 11300)
7860 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7862 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7864 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7865 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7866 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7868 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7869 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7870 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7872 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7874 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7876 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7879 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7881 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7883 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7886 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7888 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7890 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7893 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7894 SIGNATURE_BITCOIN_WALLET
,
7898 (unsigned char *) salt
.salt_buf
,
7906 free (cry_master_buf
);
7908 free (public_key_buf
);
7910 else if (hash_mode
== 11400)
7912 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7914 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7915 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7917 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7919 else if (hash_mode
== 11600)
7921 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7923 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7925 const uint data_len
= seven_zip
->data_len
;
7927 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7929 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7931 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7933 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7936 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7937 SIGNATURE_SEVEN_ZIP
,
7941 (char *) seven_zip
->salt_buf
,
7943 seven_zip
->iv_buf
[0],
7944 seven_zip
->iv_buf
[1],
7945 seven_zip
->iv_buf
[2],
7946 seven_zip
->iv_buf
[3],
7948 seven_zip
->data_len
,
7949 seven_zip
->unpack_size
,
7954 else if (hash_mode
== 11700)
7956 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7966 else if (hash_mode
== 11800)
7968 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7986 else if (hash_mode
== 11900)
7988 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7990 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7991 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7993 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7995 else if (hash_mode
== 12000)
7997 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7999 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8000 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8002 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8004 else if (hash_mode
== 12100)
8006 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8008 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8009 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8011 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8013 else if (hash_mode
== 12200)
8015 uint
*ptr_digest
= digest_buf
;
8016 uint
*ptr_salt
= salt
.salt_buf
;
8018 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8025 else if (hash_mode
== 12300)
8027 uint
*ptr_digest
= digest_buf
;
8028 uint
*ptr_salt
= salt
.salt_buf
;
8030 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",
8031 ptr_digest
[ 0], ptr_digest
[ 1],
8032 ptr_digest
[ 2], ptr_digest
[ 3],
8033 ptr_digest
[ 4], ptr_digest
[ 5],
8034 ptr_digest
[ 6], ptr_digest
[ 7],
8035 ptr_digest
[ 8], ptr_digest
[ 9],
8036 ptr_digest
[10], ptr_digest
[11],
8037 ptr_digest
[12], ptr_digest
[13],
8038 ptr_digest
[14], ptr_digest
[15],
8044 else if (hash_mode
== 12400)
8046 // encode iteration count
8050 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8051 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8052 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8053 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8058 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8059 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8060 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8061 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8066 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8068 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8069 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8071 memcpy (tmp_buf
, digest_buf
, 8);
8073 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
8077 // fill the resulting buffer
8079 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8081 else if (hash_mode
== 12500)
8083 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8085 byte_swap_32 (salt
.salt_buf
[0]),
8086 byte_swap_32 (salt
.salt_buf
[1]),
8092 else if (hash_mode
== 12600)
8094 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8095 digest_buf
[0] + salt
.salt_buf_pc
[0],
8096 digest_buf
[1] + salt
.salt_buf_pc
[1],
8097 digest_buf
[2] + salt
.salt_buf_pc
[2],
8098 digest_buf
[3] + salt
.salt_buf_pc
[3],
8099 digest_buf
[4] + salt
.salt_buf_pc
[4],
8100 digest_buf
[5] + salt
.salt_buf_pc
[5],
8101 digest_buf
[6] + salt
.salt_buf_pc
[6],
8102 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8104 else if (hash_mode
== 12700)
8106 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8108 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8109 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8111 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8113 else if (hash_mode
== 12800)
8115 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
8117 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",
8130 byte_swap_32 (digest_buf
[0]),
8131 byte_swap_32 (digest_buf
[1]),
8132 byte_swap_32 (digest_buf
[2]),
8133 byte_swap_32 (digest_buf
[3]),
8134 byte_swap_32 (digest_buf
[4]),
8135 byte_swap_32 (digest_buf
[5]),
8136 byte_swap_32 (digest_buf
[6]),
8137 byte_swap_32 (digest_buf
[7])
8140 else if (hash_mode
== 12900)
8142 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",
8151 byte_swap_32 (digest_buf
[0]),
8152 byte_swap_32 (digest_buf
[1]),
8153 byte_swap_32 (digest_buf
[2]),
8154 byte_swap_32 (digest_buf
[3]),
8155 byte_swap_32 (digest_buf
[4]),
8156 byte_swap_32 (digest_buf
[5]),
8157 byte_swap_32 (digest_buf
[6]),
8158 byte_swap_32 (digest_buf
[7]),
8165 else if (hash_mode
== 13000)
8167 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8169 rar5_t
*rar5
= &rar5s
[salt_pos
];
8171 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8181 byte_swap_32 (digest_buf
[0]),
8182 byte_swap_32 (digest_buf
[1])
8187 if (hash_type
== HASH_TYPE_MD4
)
8189 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8195 else if (hash_type
== HASH_TYPE_MD5
)
8197 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8203 else if (hash_type
== HASH_TYPE_SHA1
)
8205 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8212 else if (hash_type
== HASH_TYPE_SHA256
)
8214 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8224 else if (hash_type
== HASH_TYPE_SHA384
)
8226 uint
*ptr
= digest_buf
;
8228 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8236 else if (hash_type
== HASH_TYPE_SHA512
)
8238 uint
*ptr
= digest_buf
;
8240 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8250 else if (hash_type
== HASH_TYPE_LM
)
8252 snprintf (out_buf
, len
-1, "%08x%08x",
8256 else if (hash_type
== HASH_TYPE_ORACLEH
)
8258 snprintf (out_buf
, len
-1, "%08X%08X",
8262 else if (hash_type
== HASH_TYPE_BCRYPT
)
8264 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8265 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8267 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8269 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8271 else if (hash_type
== HASH_TYPE_KECCAK
)
8273 uint
*ptr
= digest_buf
;
8275 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",
8303 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8305 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8307 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8314 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8316 digest_buf
[ 0] = digest_buf
[ 0];
8317 digest_buf
[ 1] = digest_buf
[ 1];
8318 digest_buf
[ 2] = digest_buf
[ 2];
8319 digest_buf
[ 3] = digest_buf
[ 3];
8320 digest_buf
[ 4] = digest_buf
[ 4];
8321 digest_buf
[ 5] = digest_buf
[ 5];
8322 digest_buf
[ 6] = digest_buf
[ 6];
8323 digest_buf
[ 7] = digest_buf
[ 7];
8324 digest_buf
[ 8] = digest_buf
[ 8];
8325 digest_buf
[ 9] = digest_buf
[ 9];
8326 digest_buf
[10] = digest_buf
[10];
8327 digest_buf
[11] = digest_buf
[11];
8328 digest_buf
[12] = digest_buf
[12];
8329 digest_buf
[13] = digest_buf
[13];
8330 digest_buf
[14] = digest_buf
[14];
8331 digest_buf
[15] = digest_buf
[15];
8333 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8351 else if (hash_type
== HASH_TYPE_GOST
)
8353 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8363 else if (hash_type
== HASH_TYPE_MYSQL
)
8365 snprintf (out_buf
, len
-1, "%08x%08x",
8369 else if (hash_type
== HASH_TYPE_LOTUS5
)
8371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8377 else if (hash_type
== HASH_TYPE_LOTUS6
)
8379 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8380 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8381 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8382 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8386 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8387 memcpy (buf
+ 5, digest_buf
, 9);
8391 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8393 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8396 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8398 else if (hash_type
== HASH_TYPE_LOTUS8
)
8402 memset (buf
, 0, sizeof (buf
));
8406 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8412 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8416 buf
[26] = salt
.salt_buf_pc
[0];
8417 buf
[27] = salt
.salt_buf_pc
[1];
8421 memcpy (buf
+ 28, digest_buf
, 8);
8423 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8427 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8429 else if (hash_type
== HASH_TYPE_CRC32
)
8431 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8435 if (salt_type
== SALT_TYPE_INTERN
)
8437 size_t pos
= strlen (out_buf
);
8439 out_buf
[pos
] = data
.separator
;
8441 char *ptr
= (char *) salt
.salt_buf
;
8443 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8445 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8449 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8451 memset (hccap
, 0, sizeof (hccap_t
));
8453 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8455 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8457 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8458 wpa_t
*wpa
= &wpas
[salt_pos
];
8460 hccap
->keyver
= wpa
->keyver
;
8462 hccap
->eapol_size
= wpa
->eapol_size
;
8464 if (wpa
->keyver
!= 1)
8468 for (uint i
= 0; i
< 64; i
++)
8470 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8473 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8477 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8482 for (int i
= 5; i
< 25; i
++)
8484 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8487 char *pke_ptr
= (char *) pke_tmp
;
8489 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8490 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8491 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8492 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8494 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8496 uint dgst_size
= data
.dgst_size
;
8498 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8500 if (wpa
->keyver
!= 1)
8504 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8505 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8506 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8507 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8509 memcpy (hccap
->keymic
, digest_tmp
, 16);
8513 memcpy (hccap
->keymic
, digest_ptr
, 16);
8517 void SuspendThreads ()
8519 if (data
.devices_status
== STATUS_RUNNING
)
8521 hc_timer_set (&data
.timer_paused
);
8523 data
.devices_status
= STATUS_PAUSED
;
8525 log_info ("Paused");
8529 void ResumeThreads ()
8531 if (data
.devices_status
== STATUS_PAUSED
)
8535 hc_timer_get (data
.timer_paused
, ms_paused
);
8537 data
.ms_paused
+= ms_paused
;
8539 data
.devices_status
= STATUS_RUNNING
;
8541 log_info ("Resumed");
8547 if (data
.devices_status
!= STATUS_RUNNING
) return;
8549 data
.devices_status
= STATUS_BYPASS
;
8551 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8554 void stop_at_checkpoint ()
8556 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8558 if (data
.devices_status
!= STATUS_RUNNING
) return;
8561 // this feature only makes sense if --restore-disable was not specified
8563 if (data
.restore_disable
== 1)
8565 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8570 // check if monitoring of Restore Point updates should be enabled or disabled
8572 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8574 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8576 // save the current restore point value
8578 data
.checkpoint_cur_words
= get_lowest_words_done ();
8580 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8584 data
.devices_status
= STATUS_RUNNING
;
8586 // reset the global value for checkpoint checks
8588 data
.checkpoint_cur_words
= 0;
8590 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8596 if (data
.devices_status
== STATUS_INIT
) return;
8597 if (data
.devices_status
== STATUS_STARTING
) return;
8599 data
.devices_status
= STATUS_ABORTED
;
8604 if (data
.devices_status
== STATUS_INIT
) return;
8605 if (data
.devices_status
== STATUS_STARTING
) return;
8607 data
.devices_status
= STATUS_QUIT
;
8610 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8614 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8618 memset (&st
, 0, sizeof (st
));
8620 stat (kernel_file
, &st
);
8622 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8624 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8626 if (num_read
!= (size_t) st
.st_size
)
8628 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8635 buf
[st
.st_size
] = 0;
8637 for (int i
= 0; i
< num_devices
; i
++)
8639 kernel_lengths
[i
] = (size_t) st
.st_size
;
8641 kernel_sources
[i
] = buf
;
8646 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8654 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8656 FILE *fp
= fopen (dst
, "wb");
8658 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8668 restore_data_t
*init_restore (int argc
, char **argv
)
8670 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8672 if (data
.restore_disable
== 0)
8674 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8678 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8682 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8691 char pidbin
[BUFSIZ
];
8696 memset (pidbin
, 0, sizeof (pidbin
));
8698 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8700 FILE *fd
= fopen (pidbin
, "rb");
8704 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8706 pidbin
[pidbin_len
] = 0;
8710 char *argv0_r
= strrchr (argv
[0], '/');
8712 char *pidbin_r
= strrchr (pidbin
, '/');
8714 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8716 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8718 if (strcmp (argv0_r
, pidbin_r
) == 0)
8720 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8727 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8729 char pidbin2
[BUFSIZ
];
8733 memset (pidbin2
, 0, sizeof (pidbin2
));
8735 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8736 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8738 pidbin
[pidbin_len
] = 0;
8739 pidbin2
[pidbin2_len
] = 0;
8743 if (strcmp (pidbin
, pidbin2
) == 0)
8745 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8753 if (rd
->version_bin
< RESTORE_MIN
)
8755 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8762 memset (rd
, 0, sizeof (restore_data_t
));
8764 rd
->version_bin
= VERSION_BIN
;
8767 rd
->pid
= getpid ();
8769 rd
->pid
= GetCurrentProcessId ();
8772 if (getcwd (rd
->cwd
, 255) == NULL
)
8785 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8787 FILE *fp
= fopen (eff_restore_file
, "rb");
8791 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8796 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8798 log_error ("ERROR: cannot read %s", eff_restore_file
);
8803 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8805 for (uint i
= 0; i
< rd
->argc
; i
++)
8809 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8811 log_error ("ERROR: cannot read %s", eff_restore_file
);
8816 size_t len
= strlen (buf
);
8818 if (len
) buf
[len
- 1] = 0;
8820 rd
->argv
[i
] = mystrdup (buf
);
8827 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8831 log_error ("Restore file is corrupted");
8834 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8836 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8838 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8843 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8847 if (chdir (rd
->cwd
))
8849 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8855 uint64_t get_lowest_words_done ()
8857 uint64_t words_cur
= -1;
8859 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8861 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8863 const uint64_t words_done
= device_param
->words_done
;
8865 if (words_done
< words_cur
) words_cur
= words_done
;
8868 // It's possible that a device's workload isn't finished right after a restore-case.
8869 // In that case, this function would return 0 and overwrite the real restore point
8870 // There's also data.words_cur which is set to rd->words_cur but it changes while
8871 // the attack is running therefore we should stick to rd->words_cur.
8872 // Note that -s influences rd->words_cur we should keep a close look on that.
8874 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8879 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8881 uint64_t words_cur
= get_lowest_words_done ();
8883 rd
->words_cur
= words_cur
;
8885 FILE *fp
= fopen (new_restore_file
, "wb");
8889 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8894 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8896 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8901 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8903 for (uint i
= 0; i
< rd
->argc
; i
++)
8905 fprintf (fp
, "%s", rd
->argv
[i
]);
8911 fsync (fileno (fp
));
8916 void cycle_restore ()
8918 const char *eff_restore_file
= data
.eff_restore_file
;
8919 const char *new_restore_file
= data
.new_restore_file
;
8921 restore_data_t
*rd
= data
.rd
;
8923 write_restore (new_restore_file
, rd
);
8927 memset (&st
, 0, sizeof(st
));
8929 if (stat (eff_restore_file
, &st
) == 0)
8931 if (unlink (eff_restore_file
))
8933 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8937 if (rename (new_restore_file
, eff_restore_file
))
8939 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8943 void check_checkpoint ()
8945 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8947 uint64_t words_cur
= get_lowest_words_done ();
8949 if (words_cur
!= data
.checkpoint_cur_words
)
8959 uint
set_kernel_accel (uint hash_mode
)
8963 case 0: return GET_ACCEL (0);
8964 case 10: return GET_ACCEL (10);
8965 case 11: return GET_ACCEL (11);
8966 case 12: return GET_ACCEL (12);
8967 case 20: return GET_ACCEL (20);
8968 case 21: return GET_ACCEL (21);
8969 case 22: return GET_ACCEL (22);
8970 case 23: return GET_ACCEL (23);
8971 case 30: return GET_ACCEL (30);
8972 case 40: return GET_ACCEL (40);
8973 case 50: return GET_ACCEL (50);
8974 case 60: return GET_ACCEL (60);
8975 case 100: return GET_ACCEL (100);
8976 case 101: return GET_ACCEL (101);
8977 case 110: return GET_ACCEL (110);
8978 case 111: return GET_ACCEL (111);
8979 case 112: return GET_ACCEL (112);
8980 case 120: return GET_ACCEL (120);
8981 case 121: return GET_ACCEL (121);
8982 case 122: return GET_ACCEL (122);
8983 case 124: return GET_ACCEL (124);
8984 case 130: return GET_ACCEL (130);
8985 case 131: return GET_ACCEL (131);
8986 case 132: return GET_ACCEL (132);
8987 case 133: return GET_ACCEL (133);
8988 case 140: return GET_ACCEL (140);
8989 case 141: return GET_ACCEL (141);
8990 case 150: return GET_ACCEL (150);
8991 case 160: return GET_ACCEL (160);
8992 case 190: return GET_ACCEL (190);
8993 case 200: return GET_ACCEL (200);
8994 case 300: return GET_ACCEL (300);
8995 case 400: return GET_ACCEL (400);
8996 case 500: return GET_ACCEL (500);
8997 case 501: return GET_ACCEL (501);
8998 case 900: return GET_ACCEL (900);
8999 case 910: return GET_ACCEL (910);
9000 case 1000: return GET_ACCEL (1000);
9001 case 1100: return GET_ACCEL (1100);
9002 case 1400: return GET_ACCEL (1400);
9003 case 1410: return GET_ACCEL (1410);
9004 case 1420: return GET_ACCEL (1420);
9005 case 1421: return GET_ACCEL (1421);
9006 case 1430: return GET_ACCEL (1430);
9007 case 1440: return GET_ACCEL (1440);
9008 case 1441: return GET_ACCEL (1441);
9009 case 1450: return GET_ACCEL (1450);
9010 case 1460: return GET_ACCEL (1460);
9011 case 1500: return GET_ACCEL (1500);
9012 case 1600: return GET_ACCEL (1600);
9013 case 1700: return GET_ACCEL (1700);
9014 case 1710: return GET_ACCEL (1710);
9015 case 1711: return GET_ACCEL (1711);
9016 case 1720: return GET_ACCEL (1720);
9017 case 1722: return GET_ACCEL (1722);
9018 case 1730: return GET_ACCEL (1730);
9019 case 1731: return GET_ACCEL (1731);
9020 case 1740: return GET_ACCEL (1740);
9021 case 1750: return GET_ACCEL (1750);
9022 case 1760: return GET_ACCEL (1760);
9023 case 1800: return GET_ACCEL (1800);
9024 case 2100: return GET_ACCEL (2100);
9025 case 2400: return GET_ACCEL (2400);
9026 case 2410: return GET_ACCEL (2410);
9027 case 2500: return GET_ACCEL (2500);
9028 case 2600: return GET_ACCEL (2600);
9029 case 2611: return GET_ACCEL (2611);
9030 case 2612: return GET_ACCEL (2612);
9031 case 2711: return GET_ACCEL (2711);
9032 case 2811: return GET_ACCEL (2811);
9033 case 3000: return GET_ACCEL (3000);
9034 case 3100: return GET_ACCEL (3100);
9035 case 3200: return GET_ACCEL (3200);
9036 case 3710: return GET_ACCEL (3710);
9037 case 3711: return GET_ACCEL (3711);
9038 case 3800: return GET_ACCEL (3800);
9039 case 4300: return GET_ACCEL (4300);
9040 case 4400: return GET_ACCEL (4400);
9041 case 4500: return GET_ACCEL (4500);
9042 case 4700: return GET_ACCEL (4700);
9043 case 4800: return GET_ACCEL (4800);
9044 case 4900: return GET_ACCEL (4900);
9045 case 5000: return GET_ACCEL (5000);
9046 case 5100: return GET_ACCEL (5100);
9047 case 5200: return GET_ACCEL (5200);
9048 case 5300: return GET_ACCEL (5300);
9049 case 5400: return GET_ACCEL (5400);
9050 case 5500: return GET_ACCEL (5500);
9051 case 5600: return GET_ACCEL (5600);
9052 case 5700: return GET_ACCEL (5700);
9053 case 5800: return GET_ACCEL (5800);
9054 case 6000: return GET_ACCEL (6000);
9055 case 6100: return GET_ACCEL (6100);
9056 case 6211: return GET_ACCEL (6211);
9057 case 6212: return GET_ACCEL (6212);
9058 case 6213: return GET_ACCEL (6213);
9059 case 6221: return GET_ACCEL (6221);
9060 case 6222: return GET_ACCEL (6222);
9061 case 6223: return GET_ACCEL (6223);
9062 case 6231: return GET_ACCEL (6231);
9063 case 6232: return GET_ACCEL (6232);
9064 case 6233: return GET_ACCEL (6233);
9065 case 6241: return GET_ACCEL (6241);
9066 case 6242: return GET_ACCEL (6242);
9067 case 6243: return GET_ACCEL (6243);
9068 case 6300: return GET_ACCEL (6300);
9069 case 6400: return GET_ACCEL (6400);
9070 case 6500: return GET_ACCEL (6500);
9071 case 6600: return GET_ACCEL (6600);
9072 case 6700: return GET_ACCEL (6700);
9073 case 6800: return GET_ACCEL (6800);
9074 case 6900: return GET_ACCEL (6900);
9075 case 7100: return GET_ACCEL (7100);
9076 case 7200: return GET_ACCEL (7200);
9077 case 7300: return GET_ACCEL (7300);
9078 case 7400: return GET_ACCEL (7400);
9079 case 7500: return GET_ACCEL (7500);
9080 case 7600: return GET_ACCEL (7600);
9081 case 7700: return GET_ACCEL (7700);
9082 case 7800: return GET_ACCEL (7800);
9083 case 7900: return GET_ACCEL (7900);
9084 case 8000: return GET_ACCEL (8000);
9085 case 8100: return GET_ACCEL (8100);
9086 case 8200: return GET_ACCEL (8200);
9087 case 8300: return GET_ACCEL (8300);
9088 case 8400: return GET_ACCEL (8400);
9089 case 8500: return GET_ACCEL (8500);
9090 case 8600: return GET_ACCEL (8600);
9091 case 8700: return GET_ACCEL (8700);
9092 case 8800: return GET_ACCEL (8800);
9093 case 8900: return GET_ACCEL (8900);
9094 case 9000: return GET_ACCEL (9000);
9095 case 9100: return GET_ACCEL (9100);
9096 case 9200: return GET_ACCEL (9200);
9097 case 9300: return GET_ACCEL (9300);
9098 case 9400: return GET_ACCEL (9400);
9099 case 9500: return GET_ACCEL (9500);
9100 case 9600: return GET_ACCEL (9600);
9101 case 9700: return GET_ACCEL (9700);
9102 case 9710: return GET_ACCEL (9710);
9103 case 9720: return GET_ACCEL (9720);
9104 case 9800: return GET_ACCEL (9800);
9105 case 9810: return GET_ACCEL (9810);
9106 case 9820: return GET_ACCEL (9820);
9107 case 9900: return GET_ACCEL (9900);
9108 case 10000: return GET_ACCEL (10000);
9109 case 10100: return GET_ACCEL (10100);
9110 case 10200: return GET_ACCEL (10200);
9111 case 10300: return GET_ACCEL (10300);
9112 case 10400: return GET_ACCEL (10400);
9113 case 10410: return GET_ACCEL (10410);
9114 case 10420: return GET_ACCEL (10420);
9115 case 10500: return GET_ACCEL (10500);
9116 case 10600: return GET_ACCEL (10600);
9117 case 10700: return GET_ACCEL (10700);
9118 case 10800: return GET_ACCEL (10800);
9119 case 10900: return GET_ACCEL (10900);
9120 case 11000: return GET_ACCEL (11000);
9121 case 11100: return GET_ACCEL (11100);
9122 case 11200: return GET_ACCEL (11200);
9123 case 11300: return GET_ACCEL (11300);
9124 case 11400: return GET_ACCEL (11400);
9125 case 11500: return GET_ACCEL (11500);
9126 case 11600: return GET_ACCEL (11600);
9127 case 11700: return GET_ACCEL (11700);
9128 case 11800: return GET_ACCEL (11800);
9129 case 11900: return GET_ACCEL (11900);
9130 case 12000: return GET_ACCEL (12000);
9131 case 12100: return GET_ACCEL (12100);
9132 case 12200: return GET_ACCEL (12200);
9133 case 12300: return GET_ACCEL (12300);
9134 case 12400: return GET_ACCEL (12400);
9135 case 12500: return GET_ACCEL (12500);
9136 case 12600: return GET_ACCEL (12600);
9137 case 12700: return GET_ACCEL (12700);
9138 case 12800: return GET_ACCEL (12800);
9139 case 12900: return GET_ACCEL (12900);
9140 case 13000: return GET_ACCEL (13000);
9146 uint
set_kernel_loops (uint hash_mode
)
9150 case 0: return GET_LOOPS (0);
9151 case 10: return GET_LOOPS (10);
9152 case 11: return GET_LOOPS (11);
9153 case 12: return GET_LOOPS (12);
9154 case 20: return GET_LOOPS (20);
9155 case 21: return GET_LOOPS (21);
9156 case 22: return GET_LOOPS (22);
9157 case 23: return GET_LOOPS (23);
9158 case 30: return GET_LOOPS (30);
9159 case 40: return GET_LOOPS (40);
9160 case 50: return GET_LOOPS (50);
9161 case 60: return GET_LOOPS (60);
9162 case 100: return GET_LOOPS (100);
9163 case 101: return GET_LOOPS (101);
9164 case 110: return GET_LOOPS (110);
9165 case 111: return GET_LOOPS (111);
9166 case 112: return GET_LOOPS (112);
9167 case 120: return GET_LOOPS (120);
9168 case 121: return GET_LOOPS (121);
9169 case 122: return GET_LOOPS (122);
9170 case 124: return GET_LOOPS (124);
9171 case 130: return GET_LOOPS (130);
9172 case 131: return GET_LOOPS (131);
9173 case 132: return GET_LOOPS (132);
9174 case 133: return GET_LOOPS (133);
9175 case 140: return GET_LOOPS (140);
9176 case 141: return GET_LOOPS (141);
9177 case 150: return GET_LOOPS (150);
9178 case 160: return GET_LOOPS (160);
9179 case 190: return GET_LOOPS (190);
9180 case 200: return GET_LOOPS (200);
9181 case 300: return GET_LOOPS (300);
9182 case 400: return GET_LOOPS (400);
9183 case 500: return GET_LOOPS (500);
9184 case 501: return GET_LOOPS (501);
9185 case 900: return GET_LOOPS (900);
9186 case 910: return GET_LOOPS (910);
9187 case 1000: return GET_LOOPS (1000);
9188 case 1100: return GET_LOOPS (1100);
9189 case 1400: return GET_LOOPS (1400);
9190 case 1410: return GET_LOOPS (1410);
9191 case 1420: return GET_LOOPS (1420);
9192 case 1421: return GET_LOOPS (1421);
9193 case 1430: return GET_LOOPS (1430);
9194 case 1440: return GET_LOOPS (1440);
9195 case 1441: return GET_LOOPS (1441);
9196 case 1450: return GET_LOOPS (1450);
9197 case 1460: return GET_LOOPS (1460);
9198 case 1500: return GET_LOOPS (1500);
9199 case 1600: return GET_LOOPS (1600);
9200 case 1700: return GET_LOOPS (1700);
9201 case 1710: return GET_LOOPS (1710);
9202 case 1711: return GET_LOOPS (1711);
9203 case 1720: return GET_LOOPS (1720);
9204 case 1722: return GET_LOOPS (1722);
9205 case 1730: return GET_LOOPS (1730);
9206 case 1731: return GET_LOOPS (1731);
9207 case 1740: return GET_LOOPS (1740);
9208 case 1750: return GET_LOOPS (1750);
9209 case 1760: return GET_LOOPS (1760);
9210 case 1800: return GET_LOOPS (1800);
9211 case 2100: return GET_LOOPS (2100);
9212 case 2400: return GET_LOOPS (2400);
9213 case 2410: return GET_LOOPS (2410);
9214 case 2500: return GET_LOOPS (2500);
9215 case 2600: return GET_LOOPS (2600);
9216 case 2611: return GET_LOOPS (2611);
9217 case 2612: return GET_LOOPS (2612);
9218 case 2711: return GET_LOOPS (2711);
9219 case 2811: return GET_LOOPS (2811);
9220 case 3000: return GET_LOOPS (3000);
9221 case 3100: return GET_LOOPS (3100);
9222 case 3200: return GET_LOOPS (3200);
9223 case 3710: return GET_LOOPS (3710);
9224 case 3711: return GET_LOOPS (3711);
9225 case 3800: return GET_LOOPS (3800);
9226 case 4300: return GET_LOOPS (4300);
9227 case 4400: return GET_LOOPS (4400);
9228 case 4500: return GET_LOOPS (4500);
9229 case 4700: return GET_LOOPS (4700);
9230 case 4800: return GET_LOOPS (4800);
9231 case 4900: return GET_LOOPS (4900);
9232 case 5000: return GET_LOOPS (5000);
9233 case 5100: return GET_LOOPS (5100);
9234 case 5200: return GET_LOOPS (5200);
9235 case 5300: return GET_LOOPS (5300);
9236 case 5400: return GET_LOOPS (5400);
9237 case 5500: return GET_LOOPS (5500);
9238 case 5600: return GET_LOOPS (5600);
9239 case 5700: return GET_LOOPS (5700);
9240 case 5800: return GET_LOOPS (5800);
9241 case 6000: return GET_LOOPS (6000);
9242 case 6100: return GET_LOOPS (6100);
9243 case 6211: return GET_LOOPS (6211);
9244 case 6212: return GET_LOOPS (6212);
9245 case 6213: return GET_LOOPS (6213);
9246 case 6221: return GET_LOOPS (6221);
9247 case 6222: return GET_LOOPS (6222);
9248 case 6223: return GET_LOOPS (6223);
9249 case 6231: return GET_LOOPS (6231);
9250 case 6232: return GET_LOOPS (6232);
9251 case 6233: return GET_LOOPS (6233);
9252 case 6241: return GET_LOOPS (6241);
9253 case 6242: return GET_LOOPS (6242);
9254 case 6243: return GET_LOOPS (6243);
9255 case 6300: return GET_LOOPS (6300);
9256 case 6400: return GET_LOOPS (6400);
9257 case 6500: return GET_LOOPS (6500);
9258 case 6600: return GET_LOOPS (6600);
9259 case 6700: return GET_LOOPS (6700);
9260 case 6800: return GET_LOOPS (6800);
9261 case 6900: return GET_LOOPS (6900);
9262 case 7100: return GET_LOOPS (7100);
9263 case 7200: return GET_LOOPS (7200);
9264 case 7300: return GET_LOOPS (7300);
9265 case 7400: return GET_LOOPS (7400);
9266 case 7500: return GET_LOOPS (7500);
9267 case 7600: return GET_LOOPS (7600);
9268 case 7700: return GET_LOOPS (7700);
9269 case 7800: return GET_LOOPS (7800);
9270 case 7900: return GET_LOOPS (7900);
9271 case 8000: return GET_LOOPS (8000);
9272 case 8100: return GET_LOOPS (8100);
9273 case 8200: return GET_LOOPS (8200);
9274 case 8300: return GET_LOOPS (8300);
9275 case 8400: return GET_LOOPS (8400);
9276 case 8500: return GET_LOOPS (8500);
9277 case 8600: return GET_LOOPS (8600);
9278 case 8700: return GET_LOOPS (8700);
9279 case 8800: return GET_LOOPS (8800);
9280 case 8900: return GET_LOOPS (8900);
9281 case 9000: return GET_LOOPS (9000);
9282 case 9100: return GET_LOOPS (9100);
9283 case 9200: return GET_LOOPS (9200);
9284 case 9300: return GET_LOOPS (9300);
9285 case 9400: return GET_LOOPS (9400);
9286 case 9500: return GET_LOOPS (9500);
9287 case 9600: return GET_LOOPS (9600);
9288 case 9700: return GET_LOOPS (9700);
9289 case 9710: return GET_LOOPS (9710);
9290 case 9720: return GET_LOOPS (9720);
9291 case 9800: return GET_LOOPS (9800);
9292 case 9810: return GET_LOOPS (9810);
9293 case 9820: return GET_LOOPS (9820);
9294 case 9900: return GET_LOOPS (9900);
9295 case 10000: return GET_LOOPS (10000);
9296 case 10100: return GET_LOOPS (10100);
9297 case 10200: return GET_LOOPS (10200);
9298 case 10300: return GET_LOOPS (10300);
9299 case 10400: return GET_LOOPS (10400);
9300 case 10410: return GET_LOOPS (10410);
9301 case 10420: return GET_LOOPS (10420);
9302 case 10500: return GET_LOOPS (10500);
9303 case 10600: return GET_LOOPS (10600);
9304 case 10700: return GET_LOOPS (10700);
9305 case 10800: return GET_LOOPS (10800);
9306 case 10900: return GET_LOOPS (10900);
9307 case 11000: return GET_LOOPS (11000);
9308 case 11100: return GET_LOOPS (11100);
9309 case 11200: return GET_LOOPS (11200);
9310 case 11300: return GET_LOOPS (11300);
9311 case 11400: return GET_LOOPS (11400);
9312 case 11500: return GET_LOOPS (11500);
9313 case 11600: return GET_LOOPS (11600);
9314 case 11700: return GET_LOOPS (11700);
9315 case 11800: return GET_LOOPS (11800);
9316 case 11900: return GET_LOOPS (11900);
9317 case 12000: return GET_LOOPS (12000);
9318 case 12100: return GET_LOOPS (12100);
9319 case 12200: return GET_LOOPS (12200);
9320 case 12300: return GET_LOOPS (12300);
9321 case 12400: return GET_LOOPS (12400);
9322 case 12500: return GET_LOOPS (12500);
9323 case 12600: return GET_LOOPS (12600);
9324 case 12700: return GET_LOOPS (12700);
9325 case 12800: return GET_LOOPS (12800);
9326 case 12900: return GET_LOOPS (12900);
9327 case 13000: return GET_LOOPS (13000);
9337 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9341 if (salt_len
> sizeof(tmp
))
9346 memset (tmp
, 0, sizeof (tmp
));
9347 memcpy (tmp
, in
, salt_len
);
9349 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9351 if ((salt_len
% 2) == 0)
9353 uint new_salt_len
= salt_len
/ 2;
9355 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9357 char p0
= tmp
[j
+ 0];
9358 char p1
= tmp
[j
+ 1];
9360 tmp
[i
] = hex_convert (p1
) << 0;
9361 tmp
[i
] |= hex_convert (p0
) << 4;
9364 salt_len
= new_salt_len
;
9371 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9373 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9376 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9378 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9382 uint
*tmp_uint
= (uint
*) tmp
;
9384 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9385 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9386 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9387 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9388 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9389 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9390 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9391 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9392 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9393 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9395 salt_len
= salt_len
* 2;
9403 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9405 lowercase (tmp
, salt_len
);
9408 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9410 uppercase (tmp
, salt_len
);
9413 uint len
= salt_len
;
9415 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9420 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9425 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9427 uint
*tmp_uint
= (uint
*) tmp
;
9433 for (uint i
= 0; i
< max
; i
++)
9435 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9438 // Important: we may need to increase the length of memcpy since
9439 // we don't want to "loose" some swapped bytes (could happen if
9440 // they do not perfectly fit in the 4-byte blocks)
9441 // Memcpy does always copy the bytes in the BE order, but since
9442 // we swapped them, some important bytes could be in positions
9443 // we normally skip with the original len
9445 if (len
% 4) len
+= 4 - (len
% 4);
9448 memcpy (out
, tmp
, len
);
9453 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9455 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9457 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9459 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9461 salt_t
*salt
= hash_buf
->salt
;
9463 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9465 char *iter_pos
= input_buf
+ 4;
9467 salt
->salt_iter
= 1 << atoi (iter_pos
);
9469 char *salt_pos
= strchr (iter_pos
, '$');
9471 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9477 salt
->salt_len
= salt_len
;
9481 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9483 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9485 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9487 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9489 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9490 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9491 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9492 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9494 char *hash_pos
= salt_pos
+ 22;
9496 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9498 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9500 memcpy (digest
, tmp_buf
, 24);
9502 digest
[0] = byte_swap_32 (digest
[0]);
9503 digest
[1] = byte_swap_32 (digest
[1]);
9504 digest
[2] = byte_swap_32 (digest
[2]);
9505 digest
[3] = byte_swap_32 (digest
[3]);
9506 digest
[4] = byte_swap_32 (digest
[4]);
9507 digest
[5] = byte_swap_32 (digest
[5]);
9509 digest
[5] &= ~0xff; // its just 23 not 24 !
9514 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9516 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9518 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9522 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9524 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9526 memcpy (digest
, tmp_buf
, 32);
9528 digest
[0] = byte_swap_32 (digest
[0]);
9529 digest
[1] = byte_swap_32 (digest
[1]);
9530 digest
[2] = byte_swap_32 (digest
[2]);
9531 digest
[3] = byte_swap_32 (digest
[3]);
9532 digest
[4] = byte_swap_32 (digest
[4]);
9533 digest
[5] = byte_swap_32 (digest
[5]);
9534 digest
[6] = byte_swap_32 (digest
[6]);
9535 digest
[7] = byte_swap_32 (digest
[7]);
9537 digest
[0] -= SHA256M_A
;
9538 digest
[1] -= SHA256M_B
;
9539 digest
[2] -= SHA256M_C
;
9540 digest
[3] -= SHA256M_D
;
9541 digest
[4] -= SHA256M_E
;
9542 digest
[5] -= SHA256M_F
;
9543 digest
[6] -= SHA256M_G
;
9544 digest
[7] -= SHA256M_H
;
9549 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9551 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9553 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9555 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9556 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9558 digest
[0] = byte_swap_32 (digest
[0]);
9559 digest
[1] = byte_swap_32 (digest
[1]);
9563 IP (digest
[0], digest
[1], tt
);
9565 digest
[0] = digest
[0];
9566 digest
[1] = digest
[1];
9573 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9575 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9577 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9579 salt_t
*salt
= hash_buf
->salt
;
9581 char *hash_pos
= input_buf
+ 8;
9583 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9584 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9585 digest
[2] = hex_to_uint (&hash_pos
[16]);
9586 digest
[3] = hex_to_uint (&hash_pos
[24]);
9587 digest
[4] = hex_to_uint (&hash_pos
[32]);
9589 digest
[0] -= SHA1M_A
;
9590 digest
[1] -= SHA1M_B
;
9591 digest
[2] -= SHA1M_C
;
9592 digest
[3] -= SHA1M_D
;
9593 digest
[4] -= SHA1M_E
;
9597 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9599 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9601 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9603 salt
->salt_len
= salt_len
;
9608 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9610 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9612 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9614 salt_t
*salt
= hash_buf
->salt
;
9616 char *hash_pos
= input_buf
+ 8;
9618 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9619 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9620 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9621 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9622 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9623 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9624 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9625 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9627 digest
[0] -= SHA512M_A
;
9628 digest
[1] -= SHA512M_B
;
9629 digest
[2] -= SHA512M_C
;
9630 digest
[3] -= SHA512M_D
;
9631 digest
[4] -= SHA512M_E
;
9632 digest
[5] -= SHA512M_F
;
9633 digest
[6] -= SHA512M_G
;
9634 digest
[7] -= SHA512M_H
;
9638 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9640 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9642 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9644 salt
->salt_len
= salt_len
;
9649 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9651 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9653 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9657 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9660 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9662 salt_t
*salt
= hash_buf
->salt
;
9664 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9665 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9666 digest
[2] = hex_to_uint (&input_buf
[16]);
9667 digest
[3] = hex_to_uint (&input_buf
[24]);
9669 digest
[0] = byte_swap_32 (digest
[0]);
9670 digest
[1] = byte_swap_32 (digest
[1]);
9671 digest
[2] = byte_swap_32 (digest
[2]);
9672 digest
[3] = byte_swap_32 (digest
[3]);
9674 digest
[0] -= MD5M_A
;
9675 digest
[1] -= MD5M_B
;
9676 digest
[2] -= MD5M_C
;
9677 digest
[3] -= MD5M_D
;
9679 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9681 uint salt_len
= input_len
- 32 - 1;
9683 char *salt_buf
= input_buf
+ 32 + 1;
9685 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9687 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9689 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9691 salt
->salt_len
= salt_len
;
9696 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9698 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9700 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9704 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9709 char clean_input_buf
[32];
9711 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9712 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9714 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9718 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9724 clean_input_buf
[k
] = input_buf
[i
];
9732 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9734 salt_t
*salt
= hash_buf
->salt
;
9736 char a
, b
, c
, d
, e
, f
;
9738 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9739 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9740 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9741 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9742 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9743 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9745 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9746 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9748 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9749 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9750 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9751 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9752 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9753 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9755 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9756 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9758 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9759 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9760 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9761 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9762 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9763 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9765 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9766 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9768 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9769 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9770 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9771 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9772 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9773 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9775 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9776 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9778 digest
[0] = byte_swap_32 (digest
[0]);
9779 digest
[1] = byte_swap_32 (digest
[1]);
9780 digest
[2] = byte_swap_32 (digest
[2]);
9781 digest
[3] = byte_swap_32 (digest
[3]);
9783 digest
[0] -= MD5M_A
;
9784 digest
[1] -= MD5M_B
;
9785 digest
[2] -= MD5M_C
;
9786 digest
[3] -= MD5M_D
;
9788 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9790 uint salt_len
= input_len
- 30 - 1;
9792 char *salt_buf
= input_buf
+ 30 + 1;
9794 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9796 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9798 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9799 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9801 salt
->salt_len
= salt_len
;
9803 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9805 salt
->salt_len
+= 22;
9810 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9812 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9814 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9818 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9821 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9823 salt_t
*salt
= hash_buf
->salt
;
9825 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9826 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9827 digest
[2] = hex_to_uint (&input_buf
[16]);
9828 digest
[3] = hex_to_uint (&input_buf
[24]);
9829 digest
[4] = hex_to_uint (&input_buf
[32]);
9831 digest
[0] -= SHA1M_A
;
9832 digest
[1] -= SHA1M_B
;
9833 digest
[2] -= SHA1M_C
;
9834 digest
[3] -= SHA1M_D
;
9835 digest
[4] -= SHA1M_E
;
9837 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9839 uint salt_len
= input_len
- 40 - 1;
9841 char *salt_buf
= input_buf
+ 40 + 1;
9843 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9845 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9847 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9849 salt
->salt_len
= salt_len
;
9854 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9856 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9858 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9862 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9865 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9867 char *iter_pos
= input_buf
+ 6;
9869 salt_t
*salt
= hash_buf
->salt
;
9871 uint iter
= atoi (iter_pos
);
9878 salt
->salt_iter
= iter
- 1;
9880 char *salt_pos
= strchr (iter_pos
, '#');
9882 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9886 char *digest_pos
= strchr (salt_pos
, '#');
9888 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9892 uint salt_len
= digest_pos
- salt_pos
- 1;
9894 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9896 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9897 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9898 digest
[2] = hex_to_uint (&digest_pos
[16]);
9899 digest
[3] = hex_to_uint (&digest_pos
[24]);
9901 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9903 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9905 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9907 salt
->salt_len
= salt_len
;
9912 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9914 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9916 salt_t
*salt
= hash_buf
->salt
;
9918 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9922 memcpy (&in
, input_buf
, input_len
);
9924 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9926 memcpy (digest
, in
.keymic
, 16);
9929 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9930 The phrase "Pairwise key expansion"
9931 Access Point Address (Referred to as Authenticator Address AA)
9932 Supplicant Address (referred to as Supplicant Address SA)
9933 Access Point Nonce (referred to as Authenticator Anonce)
9934 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9937 uint salt_len
= strlen (in
.essid
);
9939 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9941 salt
->salt_len
= salt_len
;
9943 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9945 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9947 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9949 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9951 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9952 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9956 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9957 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9960 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9962 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9963 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9967 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9968 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9971 for (int i
= 0; i
< 25; i
++)
9973 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9976 wpa
->keyver
= in
.keyver
;
9978 if (wpa
->keyver
> 255)
9980 log_info ("ATTENTION!");
9981 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9982 log_info (" This could be due to a recent aircrack-ng bug.");
9983 log_info (" The key version was automatically reset to a reasonable value.");
9986 wpa
->keyver
&= 0xff;
9989 wpa
->eapol_size
= in
.eapol_size
;
9991 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9993 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9995 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9997 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9999 if (wpa
->keyver
== 1)
10005 digest
[0] = byte_swap_32 (digest
[0]);
10006 digest
[1] = byte_swap_32 (digest
[1]);
10007 digest
[2] = byte_swap_32 (digest
[2]);
10008 digest
[3] = byte_swap_32 (digest
[3]);
10010 for (int i
= 0; i
< 64; i
++)
10012 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10016 salt
->salt_buf
[10] = digest
[1];
10017 salt
->salt_buf
[11] = digest
[2];
10019 return (PARSER_OK
);
10022 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10024 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10026 salt_t
*salt
= hash_buf
->salt
;
10028 if (input_len
== 0)
10030 log_error ("Password Safe v2 container not specified");
10035 FILE *fp
= fopen (input_buf
, "rb");
10039 log_error ("%s: %s", input_buf
, strerror (errno
));
10046 uint32_t random
[2];
10048 uint32_t salt
[5]; // unused, but makes better valid check
10049 uint32_t iv
[2]; // unused, but makes better valid check
10055 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10059 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10061 salt
->salt_buf
[0] = buf
.random
[0];
10062 salt
->salt_buf
[1] = buf
.random
[1];
10064 salt
->salt_len
= 8;
10065 salt
->salt_iter
= 1000;
10067 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10068 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10069 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10070 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10071 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10073 return (PARSER_OK
);
10076 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10078 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10080 salt_t
*salt
= hash_buf
->salt
;
10082 if (input_len
== 0)
10084 log_error (".psafe3 not specified");
10089 FILE *fp
= fopen (input_buf
, "rb");
10093 log_error ("%s: %s", input_buf
, strerror (errno
));
10100 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10104 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10106 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10108 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10110 salt
->salt_iter
= in
.iterations
+ 1;
10112 salt
->salt_buf
[0] = in
.salt_buf
[0];
10113 salt
->salt_buf
[1] = in
.salt_buf
[1];
10114 salt
->salt_buf
[2] = in
.salt_buf
[2];
10115 salt
->salt_buf
[3] = in
.salt_buf
[3];
10116 salt
->salt_buf
[4] = in
.salt_buf
[4];
10117 salt
->salt_buf
[5] = in
.salt_buf
[5];
10118 salt
->salt_buf
[6] = in
.salt_buf
[6];
10119 salt
->salt_buf
[7] = in
.salt_buf
[7];
10121 salt
->salt_len
= 32;
10123 digest
[0] = in
.hash_buf
[0];
10124 digest
[1] = in
.hash_buf
[1];
10125 digest
[2] = in
.hash_buf
[2];
10126 digest
[3] = in
.hash_buf
[3];
10127 digest
[4] = in
.hash_buf
[4];
10128 digest
[5] = in
.hash_buf
[5];
10129 digest
[6] = in
.hash_buf
[6];
10130 digest
[7] = in
.hash_buf
[7];
10132 digest
[0] = byte_swap_32 (digest
[0]);
10133 digest
[1] = byte_swap_32 (digest
[1]);
10134 digest
[2] = byte_swap_32 (digest
[2]);
10135 digest
[3] = byte_swap_32 (digest
[3]);
10136 digest
[4] = byte_swap_32 (digest
[4]);
10137 digest
[5] = byte_swap_32 (digest
[5]);
10138 digest
[6] = byte_swap_32 (digest
[6]);
10139 digest
[7] = byte_swap_32 (digest
[7]);
10141 return (PARSER_OK
);
10144 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10146 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10148 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10150 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10152 salt_t
*salt
= hash_buf
->salt
;
10154 char *iter_pos
= input_buf
+ 3;
10156 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10158 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10160 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10162 salt
->salt_iter
= salt_iter
;
10164 char *salt_pos
= iter_pos
+ 1;
10168 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10170 salt
->salt_len
= salt_len
;
10172 char *hash_pos
= salt_pos
+ salt_len
;
10174 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10176 return (PARSER_OK
);
10179 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10181 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10183 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10185 salt_t
*salt
= hash_buf
->salt
;
10187 char *salt_pos
= input_buf
+ 3;
10189 uint iterations_len
= 0;
10191 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10195 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10197 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10198 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10202 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10206 iterations_len
+= 8;
10210 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10213 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10215 char *hash_pos
= strchr (salt_pos
, '$');
10217 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10219 uint salt_len
= hash_pos
- salt_pos
;
10221 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10223 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10225 salt
->salt_len
= salt_len
;
10229 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10231 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10233 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10235 return (PARSER_OK
);
10238 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10240 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10242 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10244 salt_t
*salt
= hash_buf
->salt
;
10246 char *salt_pos
= input_buf
+ 6;
10248 uint iterations_len
= 0;
10250 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10254 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10256 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10257 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10261 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10265 iterations_len
+= 8;
10269 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10272 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10274 char *hash_pos
= strchr (salt_pos
, '$');
10276 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10278 uint salt_len
= hash_pos
- salt_pos
;
10280 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10282 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10284 salt
->salt_len
= salt_len
;
10288 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10290 return (PARSER_OK
);
10293 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10295 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10297 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10299 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10301 salt_t
*salt
= hash_buf
->salt
;
10303 char *salt_pos
= input_buf
+ 14;
10305 char *hash_pos
= strchr (salt_pos
, '*');
10307 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10311 uint salt_len
= hash_pos
- salt_pos
- 1;
10313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10315 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10319 salt
->salt_len
= salt_len
;
10321 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10323 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10325 memcpy (digest
, tmp_buf
, 20);
10327 digest
[0] = byte_swap_32 (digest
[0]);
10328 digest
[1] = byte_swap_32 (digest
[1]);
10329 digest
[2] = byte_swap_32 (digest
[2]);
10330 digest
[3] = byte_swap_32 (digest
[3]);
10331 digest
[4] = byte_swap_32 (digest
[4]);
10333 digest
[0] -= SHA1M_A
;
10334 digest
[1] -= SHA1M_B
;
10335 digest
[2] -= SHA1M_C
;
10336 digest
[3] -= SHA1M_D
;
10337 digest
[4] -= SHA1M_E
;
10339 return (PARSER_OK
);
10342 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10344 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10346 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10348 if (c12
& 3) return (PARSER_HASH_VALUE
);
10350 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10352 salt_t
*salt
= hash_buf
->salt
;
10354 // for ascii_digest
10355 salt
->salt_sign
[0] = input_buf
[0];
10356 salt
->salt_sign
[1] = input_buf
[1];
10358 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10359 | itoa64_to_int (input_buf
[1]) << 6;
10361 salt
->salt_len
= 2;
10365 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10367 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10369 memcpy (digest
, tmp_buf
, 8);
10373 IP (digest
[0], digest
[1], tt
);
10378 return (PARSER_OK
);
10381 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10383 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10385 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10387 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10388 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10389 digest
[2] = hex_to_uint (&input_buf
[16]);
10390 digest
[3] = hex_to_uint (&input_buf
[24]);
10392 digest
[0] = byte_swap_32 (digest
[0]);
10393 digest
[1] = byte_swap_32 (digest
[1]);
10394 digest
[2] = byte_swap_32 (digest
[2]);
10395 digest
[3] = byte_swap_32 (digest
[3]);
10397 digest
[0] -= MD4M_A
;
10398 digest
[1] -= MD4M_B
;
10399 digest
[2] -= MD4M_C
;
10400 digest
[3] -= MD4M_D
;
10402 return (PARSER_OK
);
10405 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10407 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10409 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10413 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10416 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10418 salt_t
*salt
= hash_buf
->salt
;
10420 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10421 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10422 digest
[2] = hex_to_uint (&input_buf
[16]);
10423 digest
[3] = hex_to_uint (&input_buf
[24]);
10425 digest
[0] = byte_swap_32 (digest
[0]);
10426 digest
[1] = byte_swap_32 (digest
[1]);
10427 digest
[2] = byte_swap_32 (digest
[2]);
10428 digest
[3] = byte_swap_32 (digest
[3]);
10430 digest
[0] -= MD4M_A
;
10431 digest
[1] -= MD4M_B
;
10432 digest
[2] -= MD4M_C
;
10433 digest
[3] -= MD4M_D
;
10435 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10437 uint salt_len
= input_len
- 32 - 1;
10439 char *salt_buf
= input_buf
+ 32 + 1;
10441 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10443 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10445 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10447 salt
->salt_len
= salt_len
;
10449 return (PARSER_OK
);
10452 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10454 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10456 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10458 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10459 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10460 digest
[2] = hex_to_uint (&input_buf
[16]);
10461 digest
[3] = hex_to_uint (&input_buf
[24]);
10463 digest
[0] = byte_swap_32 (digest
[0]);
10464 digest
[1] = byte_swap_32 (digest
[1]);
10465 digest
[2] = byte_swap_32 (digest
[2]);
10466 digest
[3] = byte_swap_32 (digest
[3]);
10468 digest
[0] -= MD5M_A
;
10469 digest
[1] -= MD5M_B
;
10470 digest
[2] -= MD5M_C
;
10471 digest
[3] -= MD5M_D
;
10473 return (PARSER_OK
);
10476 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10478 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10480 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10482 digest
[0] = hex_to_uint (&input_buf
[0]);
10483 digest
[1] = hex_to_uint (&input_buf
[8]);
10487 digest
[0] = byte_swap_32 (digest
[0]);
10488 digest
[1] = byte_swap_32 (digest
[1]);
10490 return (PARSER_OK
);
10493 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10495 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10497 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10501 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10504 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10506 salt_t
*salt
= hash_buf
->salt
;
10508 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10509 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10510 digest
[2] = hex_to_uint (&input_buf
[16]);
10511 digest
[3] = hex_to_uint (&input_buf
[24]);
10513 digest
[0] = byte_swap_32 (digest
[0]);
10514 digest
[1] = byte_swap_32 (digest
[1]);
10515 digest
[2] = byte_swap_32 (digest
[2]);
10516 digest
[3] = byte_swap_32 (digest
[3]);
10518 digest
[0] -= MD5M_A
;
10519 digest
[1] -= MD5M_B
;
10520 digest
[2] -= MD5M_C
;
10521 digest
[3] -= MD5M_D
;
10523 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10525 uint salt_len
= input_len
- 32 - 1;
10527 char *salt_buf
= input_buf
+ 32 + 1;
10529 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10531 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10533 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10535 salt
->salt_len
= salt_len
;
10537 return (PARSER_OK
);
10540 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10542 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10544 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10546 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10547 | itoa64_to_int (input_buf
[ 1]) << 6
10548 | itoa64_to_int (input_buf
[ 2]) << 12
10549 | itoa64_to_int (input_buf
[ 3]) << 18;
10550 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10551 | itoa64_to_int (input_buf
[ 5]) << 6
10552 | itoa64_to_int (input_buf
[ 6]) << 12
10553 | itoa64_to_int (input_buf
[ 7]) << 18;
10554 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10555 | itoa64_to_int (input_buf
[ 9]) << 6
10556 | itoa64_to_int (input_buf
[10]) << 12
10557 | itoa64_to_int (input_buf
[11]) << 18;
10558 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10559 | itoa64_to_int (input_buf
[13]) << 6
10560 | itoa64_to_int (input_buf
[14]) << 12
10561 | itoa64_to_int (input_buf
[15]) << 18;
10563 digest
[0] -= MD5M_A
;
10564 digest
[1] -= MD5M_B
;
10565 digest
[2] -= MD5M_C
;
10566 digest
[3] -= MD5M_D
;
10568 digest
[0] &= 0x00ffffff;
10569 digest
[1] &= 0x00ffffff;
10570 digest
[2] &= 0x00ffffff;
10571 digest
[3] &= 0x00ffffff;
10573 return (PARSER_OK
);
10576 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10578 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10580 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10584 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10587 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10589 salt_t
*salt
= hash_buf
->salt
;
10591 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10592 | itoa64_to_int (input_buf
[ 1]) << 6
10593 | itoa64_to_int (input_buf
[ 2]) << 12
10594 | itoa64_to_int (input_buf
[ 3]) << 18;
10595 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10596 | itoa64_to_int (input_buf
[ 5]) << 6
10597 | itoa64_to_int (input_buf
[ 6]) << 12
10598 | itoa64_to_int (input_buf
[ 7]) << 18;
10599 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10600 | itoa64_to_int (input_buf
[ 9]) << 6
10601 | itoa64_to_int (input_buf
[10]) << 12
10602 | itoa64_to_int (input_buf
[11]) << 18;
10603 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10604 | itoa64_to_int (input_buf
[13]) << 6
10605 | itoa64_to_int (input_buf
[14]) << 12
10606 | itoa64_to_int (input_buf
[15]) << 18;
10608 digest
[0] -= MD5M_A
;
10609 digest
[1] -= MD5M_B
;
10610 digest
[2] -= MD5M_C
;
10611 digest
[3] -= MD5M_D
;
10613 digest
[0] &= 0x00ffffff;
10614 digest
[1] &= 0x00ffffff;
10615 digest
[2] &= 0x00ffffff;
10616 digest
[3] &= 0x00ffffff;
10618 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10620 uint salt_len
= input_len
- 16 - 1;
10622 char *salt_buf
= input_buf
+ 16 + 1;
10624 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10626 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10628 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10630 salt
->salt_len
= salt_len
;
10632 return (PARSER_OK
);
10635 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10637 key
[0] = (nthash
[0] >> 0);
10638 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10639 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10640 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10641 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10642 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10643 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10644 key
[7] = (nthash
[6] << 1);
10656 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10658 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10660 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10662 salt_t
*salt
= hash_buf
->salt
;
10664 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10670 char *user_pos
= input_buf
;
10672 char *unused_pos
= strchr (user_pos
, ':');
10674 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10676 uint user_len
= unused_pos
- user_pos
;
10678 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10682 char *domain_pos
= strchr (unused_pos
, ':');
10684 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10686 uint unused_len
= domain_pos
- unused_pos
;
10688 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10692 char *srvchall_pos
= strchr (domain_pos
, ':');
10694 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10696 uint domain_len
= srvchall_pos
- domain_pos
;
10698 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10702 char *hash_pos
= strchr (srvchall_pos
, ':');
10704 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10706 uint srvchall_len
= hash_pos
- srvchall_pos
;
10708 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10712 char *clichall_pos
= strchr (hash_pos
, ':');
10714 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10716 uint hash_len
= clichall_pos
- hash_pos
;
10718 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10722 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10724 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10727 * store some data for later use
10730 netntlm
->user_len
= user_len
* 2;
10731 netntlm
->domain_len
= domain_len
* 2;
10732 netntlm
->srvchall_len
= srvchall_len
/ 2;
10733 netntlm
->clichall_len
= clichall_len
/ 2;
10735 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10736 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10739 * handle username and domainname
10742 for (uint i
= 0; i
< user_len
; i
++)
10744 *userdomain_ptr
++ = user_pos
[i
];
10745 *userdomain_ptr
++ = 0;
10748 for (uint i
= 0; i
< domain_len
; i
++)
10750 *userdomain_ptr
++ = domain_pos
[i
];
10751 *userdomain_ptr
++ = 0;
10755 * handle server challenge encoding
10758 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10760 const char p0
= srvchall_pos
[i
+ 0];
10761 const char p1
= srvchall_pos
[i
+ 1];
10763 *chall_ptr
++ = hex_convert (p1
) << 0
10764 | hex_convert (p0
) << 4;
10768 * handle client challenge encoding
10771 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10773 const char p0
= clichall_pos
[i
+ 0];
10774 const char p1
= clichall_pos
[i
+ 1];
10776 *chall_ptr
++ = hex_convert (p1
) << 0
10777 | hex_convert (p0
) << 4;
10784 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10786 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10788 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10790 salt
->salt_len
= salt_len
;
10792 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10793 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10794 digest
[2] = hex_to_uint (&hash_pos
[16]);
10795 digest
[3] = hex_to_uint (&hash_pos
[24]);
10797 digest
[0] = byte_swap_32 (digest
[0]);
10798 digest
[1] = byte_swap_32 (digest
[1]);
10799 digest
[2] = byte_swap_32 (digest
[2]);
10800 digest
[3] = byte_swap_32 (digest
[3]);
10802 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10804 uint digest_tmp
[2];
10806 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10807 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10809 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10810 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10812 /* special case 2: ESS */
10814 if (srvchall_len
== 48)
10816 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10820 w
[ 0] = netntlm
->chall_buf
[6];
10821 w
[ 1] = netntlm
->chall_buf
[7];
10822 w
[ 2] = netntlm
->chall_buf
[0];
10823 w
[ 3] = netntlm
->chall_buf
[1];
10846 salt
->salt_buf
[0] = dgst
[0];
10847 salt
->salt_buf
[1] = dgst
[1];
10851 /* precompute netntlmv1 exploit start */
10853 for (uint i
= 0; i
< 0x10000; i
++)
10855 uint key_md4
[2] = { i
, 0 };
10856 uint key_des
[2] = { 0, 0 };
10858 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10863 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10865 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10867 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10869 if (data3
[0] != digest_tmp
[0]) continue;
10870 if (data3
[1] != digest_tmp
[1]) continue;
10872 salt
->salt_buf
[2] = i
;
10874 salt
->salt_len
= 24;
10879 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10880 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10882 /* precompute netntlmv1 exploit stop */
10886 IP (digest
[0], digest
[1], tt
);
10887 IP (digest
[2], digest
[3], tt
);
10889 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10890 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10891 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10892 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10894 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10896 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10897 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10899 return (PARSER_OK
);
10902 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10904 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10906 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10908 salt_t
*salt
= hash_buf
->salt
;
10910 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10916 char *user_pos
= input_buf
;
10918 char *unused_pos
= strchr (user_pos
, ':');
10920 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10922 uint user_len
= unused_pos
- user_pos
;
10924 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10928 char *domain_pos
= strchr (unused_pos
, ':');
10930 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10932 uint unused_len
= domain_pos
- unused_pos
;
10934 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10938 char *srvchall_pos
= strchr (domain_pos
, ':');
10940 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10942 uint domain_len
= srvchall_pos
- domain_pos
;
10944 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10948 char *hash_pos
= strchr (srvchall_pos
, ':');
10950 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10952 uint srvchall_len
= hash_pos
- srvchall_pos
;
10954 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10958 char *clichall_pos
= strchr (hash_pos
, ':');
10960 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10962 uint hash_len
= clichall_pos
- hash_pos
;
10964 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10968 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10970 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10972 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10975 * store some data for later use
10978 netntlm
->user_len
= user_len
* 2;
10979 netntlm
->domain_len
= domain_len
* 2;
10980 netntlm
->srvchall_len
= srvchall_len
/ 2;
10981 netntlm
->clichall_len
= clichall_len
/ 2;
10983 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10984 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10987 * handle username and domainname
10990 for (uint i
= 0; i
< user_len
; i
++)
10992 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10993 *userdomain_ptr
++ = 0;
10996 for (uint i
= 0; i
< domain_len
; i
++)
10998 *userdomain_ptr
++ = domain_pos
[i
];
10999 *userdomain_ptr
++ = 0;
11002 *userdomain_ptr
++ = 0x80;
11005 * handle server challenge encoding
11008 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11010 const char p0
= srvchall_pos
[i
+ 0];
11011 const char p1
= srvchall_pos
[i
+ 1];
11013 *chall_ptr
++ = hex_convert (p1
) << 0
11014 | hex_convert (p0
) << 4;
11018 * handle client challenge encoding
11021 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11023 const char p0
= clichall_pos
[i
+ 0];
11024 const char p1
= clichall_pos
[i
+ 1];
11026 *chall_ptr
++ = hex_convert (p1
) << 0
11027 | hex_convert (p0
) << 4;
11030 *chall_ptr
++ = 0x80;
11033 * handle hash itself
11036 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11037 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11038 digest
[2] = hex_to_uint (&hash_pos
[16]);
11039 digest
[3] = hex_to_uint (&hash_pos
[24]);
11041 digest
[0] = byte_swap_32 (digest
[0]);
11042 digest
[1] = byte_swap_32 (digest
[1]);
11043 digest
[2] = byte_swap_32 (digest
[2]);
11044 digest
[3] = byte_swap_32 (digest
[3]);
11047 * reuse challange data as salt_buf, its the buffer that is most likely unique
11050 salt
->salt_buf
[0] = 0;
11051 salt
->salt_buf
[1] = 0;
11052 salt
->salt_buf
[2] = 0;
11053 salt
->salt_buf
[3] = 0;
11054 salt
->salt_buf
[4] = 0;
11055 salt
->salt_buf
[5] = 0;
11056 salt
->salt_buf
[6] = 0;
11057 salt
->salt_buf
[7] = 0;
11061 uptr
= (uint
*) netntlm
->userdomain_buf
;
11063 for (uint i
= 0; i
< 16; i
+= 16)
11065 md5_64 (uptr
, salt
->salt_buf
);
11068 uptr
= (uint
*) netntlm
->chall_buf
;
11070 for (uint i
= 0; i
< 256; i
+= 16)
11072 md5_64 (uptr
, salt
->salt_buf
);
11075 salt
->salt_len
= 16;
11077 return (PARSER_OK
);
11080 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11082 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11084 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11088 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11091 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11093 salt_t
*salt
= hash_buf
->salt
;
11095 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11096 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11097 digest
[2] = hex_to_uint (&input_buf
[16]);
11098 digest
[3] = hex_to_uint (&input_buf
[24]);
11100 digest
[0] = byte_swap_32 (digest
[0]);
11101 digest
[1] = byte_swap_32 (digest
[1]);
11102 digest
[2] = byte_swap_32 (digest
[2]);
11103 digest
[3] = byte_swap_32 (digest
[3]);
11105 digest
[0] -= MD5M_A
;
11106 digest
[1] -= MD5M_B
;
11107 digest
[2] -= MD5M_C
;
11108 digest
[3] -= MD5M_D
;
11110 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11112 uint salt_len
= input_len
- 32 - 1;
11114 char *salt_buf
= input_buf
+ 32 + 1;
11116 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11118 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11120 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11122 salt
->salt_len
= salt_len
;
11124 return (PARSER_OK
);
11127 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11129 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11131 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11135 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11138 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11140 salt_t
*salt
= hash_buf
->salt
;
11142 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11143 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11144 digest
[2] = hex_to_uint (&input_buf
[16]);
11145 digest
[3] = hex_to_uint (&input_buf
[24]);
11147 digest
[0] = byte_swap_32 (digest
[0]);
11148 digest
[1] = byte_swap_32 (digest
[1]);
11149 digest
[2] = byte_swap_32 (digest
[2]);
11150 digest
[3] = byte_swap_32 (digest
[3]);
11152 digest
[0] -= MD5M_A
;
11153 digest
[1] -= MD5M_B
;
11154 digest
[2] -= MD5M_C
;
11155 digest
[3] -= MD5M_D
;
11157 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11159 uint salt_len
= input_len
- 32 - 1;
11161 char *salt_buf
= input_buf
+ 32 + 1;
11163 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11165 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11167 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11169 salt
->salt_len
= salt_len
;
11171 return (PARSER_OK
);
11174 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11176 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11178 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11180 salt_t
*salt
= hash_buf
->salt
;
11182 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11183 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11184 digest
[2] = hex_to_uint (&input_buf
[16]);
11185 digest
[3] = hex_to_uint (&input_buf
[24]);
11187 digest
[0] = byte_swap_32 (digest
[0]);
11188 digest
[1] = byte_swap_32 (digest
[1]);
11189 digest
[2] = byte_swap_32 (digest
[2]);
11190 digest
[3] = byte_swap_32 (digest
[3]);
11192 digest
[0] -= MD5M_A
;
11193 digest
[1] -= MD5M_B
;
11194 digest
[2] -= MD5M_C
;
11195 digest
[3] -= MD5M_D
;
11198 * This is a virtual salt. While the algorithm is basically not salted
11199 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11200 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11203 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11205 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11207 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11209 salt
->salt_len
= salt_len
;
11211 return (PARSER_OK
);
11214 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11216 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11218 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11222 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11225 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11227 salt_t
*salt
= hash_buf
->salt
;
11229 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11230 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11231 digest
[2] = hex_to_uint (&input_buf
[16]);
11232 digest
[3] = hex_to_uint (&input_buf
[24]);
11234 digest
[0] = byte_swap_32 (digest
[0]);
11235 digest
[1] = byte_swap_32 (digest
[1]);
11236 digest
[2] = byte_swap_32 (digest
[2]);
11237 digest
[3] = byte_swap_32 (digest
[3]);
11239 digest
[0] -= MD5M_A
;
11240 digest
[1] -= MD5M_B
;
11241 digest
[2] -= MD5M_C
;
11242 digest
[3] -= MD5M_D
;
11244 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11246 uint salt_len
= input_len
- 32 - 1;
11248 char *salt_buf
= input_buf
+ 32 + 1;
11250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11256 salt
->salt_len
= salt_len
;
11258 return (PARSER_OK
);
11261 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11263 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11265 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11269 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11272 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11274 salt_t
*salt
= hash_buf
->salt
;
11276 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11277 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11278 digest
[2] = hex_to_uint (&input_buf
[16]);
11279 digest
[3] = hex_to_uint (&input_buf
[24]);
11281 digest
[0] = byte_swap_32 (digest
[0]);
11282 digest
[1] = byte_swap_32 (digest
[1]);
11283 digest
[2] = byte_swap_32 (digest
[2]);
11284 digest
[3] = byte_swap_32 (digest
[3]);
11286 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11288 uint salt_len
= input_len
- 32 - 1;
11290 char *salt_buf
= input_buf
+ 32 + 1;
11292 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11294 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11296 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11298 salt
->salt_len
= salt_len
;
11300 return (PARSER_OK
);
11303 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11305 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11307 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11311 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11314 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11316 salt_t
*salt
= hash_buf
->salt
;
11318 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11319 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11320 digest
[2] = hex_to_uint (&input_buf
[16]);
11321 digest
[3] = hex_to_uint (&input_buf
[24]);
11323 digest
[0] = byte_swap_32 (digest
[0]);
11324 digest
[1] = byte_swap_32 (digest
[1]);
11325 digest
[2] = byte_swap_32 (digest
[2]);
11326 digest
[3] = byte_swap_32 (digest
[3]);
11328 digest
[0] -= MD4M_A
;
11329 digest
[1] -= MD4M_B
;
11330 digest
[2] -= MD4M_C
;
11331 digest
[3] -= MD4M_D
;
11333 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11335 uint salt_len
= input_len
- 32 - 1;
11337 char *salt_buf
= input_buf
+ 32 + 1;
11339 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11341 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11343 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11345 salt
->salt_len
= salt_len
;
11347 return (PARSER_OK
);
11350 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11352 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11354 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11358 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11361 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11363 salt_t
*salt
= hash_buf
->salt
;
11365 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11366 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11367 digest
[2] = hex_to_uint (&input_buf
[16]);
11368 digest
[3] = hex_to_uint (&input_buf
[24]);
11370 digest
[0] = byte_swap_32 (digest
[0]);
11371 digest
[1] = byte_swap_32 (digest
[1]);
11372 digest
[2] = byte_swap_32 (digest
[2]);
11373 digest
[3] = byte_swap_32 (digest
[3]);
11375 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11377 uint salt_len
= input_len
- 32 - 1;
11379 char *salt_buf
= input_buf
+ 32 + 1;
11381 uint salt_pc_block
[16];
11383 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11385 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11387 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11389 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11391 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11393 salt_pc_block
[14] = salt_len
* 8;
11395 uint salt_pc_digest
[4];
11397 salt_pc_digest
[0] = MAGIC_A
;
11398 salt_pc_digest
[1] = MAGIC_B
;
11399 salt_pc_digest
[2] = MAGIC_C
;
11400 salt_pc_digest
[3] = MAGIC_D
;
11402 md5_64 (salt_pc_block
, salt_pc_digest
);
11404 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11405 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11406 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11407 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11409 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11411 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11413 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11415 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11416 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11417 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11418 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11420 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11422 return (PARSER_OK
);
11425 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11427 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11429 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11431 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11432 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11433 digest
[2] = hex_to_uint (&input_buf
[16]);
11434 digest
[3] = hex_to_uint (&input_buf
[24]);
11435 digest
[4] = hex_to_uint (&input_buf
[32]);
11437 digest
[0] -= SHA1M_A
;
11438 digest
[1] -= SHA1M_B
;
11439 digest
[2] -= SHA1M_C
;
11440 digest
[3] -= SHA1M_D
;
11441 digest
[4] -= SHA1M_E
;
11443 return (PARSER_OK
);
11446 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11448 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11450 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11452 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11453 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11454 digest
[2] = hex_to_uint (&input_buf
[16]);
11455 digest
[3] = hex_to_uint (&input_buf
[24]);
11456 digest
[4] = hex_to_uint (&input_buf
[32]);
11458 return (PARSER_OK
);
11461 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11463 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11465 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11469 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11472 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11474 salt_t
*salt
= hash_buf
->salt
;
11476 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11477 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11478 digest
[2] = hex_to_uint (&input_buf
[16]);
11479 digest
[3] = hex_to_uint (&input_buf
[24]);
11480 digest
[4] = hex_to_uint (&input_buf
[32]);
11482 digest
[0] -= SHA1M_A
;
11483 digest
[1] -= SHA1M_B
;
11484 digest
[2] -= SHA1M_C
;
11485 digest
[3] -= SHA1M_D
;
11486 digest
[4] -= SHA1M_E
;
11488 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11490 uint salt_len
= input_len
- 40 - 1;
11492 char *salt_buf
= input_buf
+ 40 + 1;
11494 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11496 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11498 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11500 salt
->salt_len
= salt_len
;
11502 return (PARSER_OK
);
11505 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11507 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11509 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11511 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11515 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11517 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11519 memcpy (digest
, tmp_buf
, 20);
11521 digest
[0] = byte_swap_32 (digest
[0]);
11522 digest
[1] = byte_swap_32 (digest
[1]);
11523 digest
[2] = byte_swap_32 (digest
[2]);
11524 digest
[3] = byte_swap_32 (digest
[3]);
11525 digest
[4] = byte_swap_32 (digest
[4]);
11527 digest
[0] -= SHA1M_A
;
11528 digest
[1] -= SHA1M_B
;
11529 digest
[2] -= SHA1M_C
;
11530 digest
[3] -= SHA1M_D
;
11531 digest
[4] -= SHA1M_E
;
11533 return (PARSER_OK
);
11536 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11538 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11540 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11542 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11544 salt_t
*salt
= hash_buf
->salt
;
11548 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11550 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11552 memcpy (digest
, tmp_buf
, 20);
11554 salt
->salt_len
= tmp_len
- 20;
11556 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11558 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11560 char *ptr
= (char *) salt
->salt_buf
;
11562 ptr
[salt
->salt_len
] = 0x80;
11565 digest
[0] = byte_swap_32 (digest
[0]);
11566 digest
[1] = byte_swap_32 (digest
[1]);
11567 digest
[2] = byte_swap_32 (digest
[2]);
11568 digest
[3] = byte_swap_32 (digest
[3]);
11569 digest
[4] = byte_swap_32 (digest
[4]);
11571 digest
[0] -= SHA1M_A
;
11572 digest
[1] -= SHA1M_B
;
11573 digest
[2] -= SHA1M_C
;
11574 digest
[3] -= SHA1M_D
;
11575 digest
[4] -= SHA1M_E
;
11577 return (PARSER_OK
);
11580 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11582 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11584 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11586 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11588 salt_t
*salt
= hash_buf
->salt
;
11590 char *salt_buf
= input_buf
+ 6;
11594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11596 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11598 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11600 salt
->salt_len
= salt_len
;
11602 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11604 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11605 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11606 digest
[2] = hex_to_uint (&hash_pos
[16]);
11607 digest
[3] = hex_to_uint (&hash_pos
[24]);
11608 digest
[4] = hex_to_uint (&hash_pos
[32]);
11610 digest
[0] -= SHA1M_A
;
11611 digest
[1] -= SHA1M_B
;
11612 digest
[2] -= SHA1M_C
;
11613 digest
[3] -= SHA1M_D
;
11614 digest
[4] -= SHA1M_E
;
11616 return (PARSER_OK
);
11619 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11621 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11623 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11625 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11627 salt_t
*salt
= hash_buf
->salt
;
11629 char *salt_buf
= input_buf
+ 6;
11633 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11635 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11637 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11639 salt
->salt_len
= salt_len
;
11641 char *hash_pos
= input_buf
+ 6 + 8;
11643 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11644 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11645 digest
[2] = hex_to_uint (&hash_pos
[16]);
11646 digest
[3] = hex_to_uint (&hash_pos
[24]);
11647 digest
[4] = hex_to_uint (&hash_pos
[32]);
11649 digest
[0] -= SHA1M_A
;
11650 digest
[1] -= SHA1M_B
;
11651 digest
[2] -= SHA1M_C
;
11652 digest
[3] -= SHA1M_D
;
11653 digest
[4] -= SHA1M_E
;
11655 return (PARSER_OK
);
11658 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11660 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11662 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11664 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11666 salt_t
*salt
= hash_buf
->salt
;
11668 char *salt_buf
= input_buf
+ 6;
11672 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11674 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11676 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11678 salt
->salt_len
= salt_len
;
11680 char *hash_pos
= input_buf
+ 6 + 8;
11682 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11683 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11684 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11685 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11686 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11687 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11688 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11689 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11691 digest
[0] -= SHA512M_A
;
11692 digest
[1] -= SHA512M_B
;
11693 digest
[2] -= SHA512M_C
;
11694 digest
[3] -= SHA512M_D
;
11695 digest
[4] -= SHA512M_E
;
11696 digest
[5] -= SHA512M_F
;
11697 digest
[6] -= SHA512M_G
;
11698 digest
[7] -= SHA512M_H
;
11700 return (PARSER_OK
);
11703 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11705 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11707 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11711 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11714 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11716 salt_t
*salt
= hash_buf
->salt
;
11718 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11719 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11723 digest
[0] = byte_swap_32 (digest
[0]);
11724 digest
[1] = byte_swap_32 (digest
[1]);
11726 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11728 uint salt_len
= input_len
- 16 - 1;
11730 char *salt_buf
= input_buf
+ 16 + 1;
11732 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11734 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11736 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11738 salt
->salt_len
= salt_len
;
11740 return (PARSER_OK
);
11743 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11745 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11747 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11749 salt_t
*salt
= hash_buf
->salt
;
11751 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11752 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11753 digest
[2] = hex_to_uint (&input_buf
[16]);
11754 digest
[3] = hex_to_uint (&input_buf
[24]);
11755 digest
[4] = hex_to_uint (&input_buf
[32]);
11757 digest
[0] -= SHA1M_A
;
11758 digest
[1] -= SHA1M_B
;
11759 digest
[2] -= SHA1M_C
;
11760 digest
[3] -= SHA1M_D
;
11761 digest
[4] -= SHA1M_E
;
11763 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11765 uint salt_len
= input_len
- 40 - 1;
11767 char *salt_buf
= input_buf
+ 40 + 1;
11769 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11771 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11773 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11775 salt
->salt_len
= salt_len
;
11777 return (PARSER_OK
);
11780 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11782 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11784 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11786 salt_t
*salt
= hash_buf
->salt
;
11788 char *hash_pos
= input_buf
;
11790 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11791 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11792 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11793 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11794 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11795 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11796 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11797 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11798 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11799 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11800 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11801 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11802 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11803 digest
[13] = hex_to_uint (&hash_pos
[104]);
11804 digest
[14] = hex_to_uint (&hash_pos
[112]);
11805 digest
[15] = hex_to_uint (&hash_pos
[120]);
11807 char *salt_pos
= input_buf
+ 128;
11809 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11810 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11811 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11812 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11814 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11815 salt
->salt_len
= 16;
11817 return (PARSER_OK
);
11820 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11822 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11824 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11826 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11827 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11828 digest
[2] = hex_to_uint (&input_buf
[16]);
11829 digest
[3] = hex_to_uint (&input_buf
[24]);
11830 digest
[4] = hex_to_uint (&input_buf
[32]);
11831 digest
[5] = hex_to_uint (&input_buf
[40]);
11832 digest
[6] = hex_to_uint (&input_buf
[48]);
11833 digest
[7] = hex_to_uint (&input_buf
[56]);
11835 digest
[0] -= SHA256M_A
;
11836 digest
[1] -= SHA256M_B
;
11837 digest
[2] -= SHA256M_C
;
11838 digest
[3] -= SHA256M_D
;
11839 digest
[4] -= SHA256M_E
;
11840 digest
[5] -= SHA256M_F
;
11841 digest
[6] -= SHA256M_G
;
11842 digest
[7] -= SHA256M_H
;
11844 return (PARSER_OK
);
11847 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11849 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11851 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11855 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11858 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11860 salt_t
*salt
= hash_buf
->salt
;
11862 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11863 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11864 digest
[2] = hex_to_uint (&input_buf
[16]);
11865 digest
[3] = hex_to_uint (&input_buf
[24]);
11866 digest
[4] = hex_to_uint (&input_buf
[32]);
11867 digest
[5] = hex_to_uint (&input_buf
[40]);
11868 digest
[6] = hex_to_uint (&input_buf
[48]);
11869 digest
[7] = hex_to_uint (&input_buf
[56]);
11871 digest
[0] -= SHA256M_A
;
11872 digest
[1] -= SHA256M_B
;
11873 digest
[2] -= SHA256M_C
;
11874 digest
[3] -= SHA256M_D
;
11875 digest
[4] -= SHA256M_E
;
11876 digest
[5] -= SHA256M_F
;
11877 digest
[6] -= SHA256M_G
;
11878 digest
[7] -= SHA256M_H
;
11880 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11882 uint salt_len
= input_len
- 64 - 1;
11884 char *salt_buf
= input_buf
+ 64 + 1;
11886 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11888 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11890 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11892 salt
->salt_len
= salt_len
;
11894 return (PARSER_OK
);
11897 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11899 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11901 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11903 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11904 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11905 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11906 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11907 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11908 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11912 digest
[0] -= SHA384M_A
;
11913 digest
[1] -= SHA384M_B
;
11914 digest
[2] -= SHA384M_C
;
11915 digest
[3] -= SHA384M_D
;
11916 digest
[4] -= SHA384M_E
;
11917 digest
[5] -= SHA384M_F
;
11921 return (PARSER_OK
);
11924 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11926 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11928 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11930 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11931 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11932 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11933 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11934 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11935 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11936 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11937 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11939 digest
[0] -= SHA512M_A
;
11940 digest
[1] -= SHA512M_B
;
11941 digest
[2] -= SHA512M_C
;
11942 digest
[3] -= SHA512M_D
;
11943 digest
[4] -= SHA512M_E
;
11944 digest
[5] -= SHA512M_F
;
11945 digest
[6] -= SHA512M_G
;
11946 digest
[7] -= SHA512M_H
;
11948 return (PARSER_OK
);
11951 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11953 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11955 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11959 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11962 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11964 salt_t
*salt
= hash_buf
->salt
;
11966 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11967 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11968 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11969 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11970 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11971 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11972 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11973 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11975 digest
[0] -= SHA512M_A
;
11976 digest
[1] -= SHA512M_B
;
11977 digest
[2] -= SHA512M_C
;
11978 digest
[3] -= SHA512M_D
;
11979 digest
[4] -= SHA512M_E
;
11980 digest
[5] -= SHA512M_F
;
11981 digest
[6] -= SHA512M_G
;
11982 digest
[7] -= SHA512M_H
;
11984 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11986 uint salt_len
= input_len
- 128 - 1;
11988 char *salt_buf
= input_buf
+ 128 + 1;
11990 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11992 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11994 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11996 salt
->salt_len
= salt_len
;
11998 return (PARSER_OK
);
12001 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12003 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12005 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12007 salt_t
*salt
= hash_buf
->salt
;
12009 char *salt_pos
= input_buf
+ 3;
12011 uint iterations_len
= 0;
12013 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12017 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12019 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12020 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12024 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12028 iterations_len
+= 8;
12032 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12035 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12037 char *hash_pos
= strchr (salt_pos
, '$');
12039 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12041 uint salt_len
= hash_pos
- salt_pos
;
12043 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12045 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12047 salt
->salt_len
= salt_len
;
12051 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12053 return (PARSER_OK
);
12056 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12058 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12060 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12062 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12064 salt_t
*salt
= hash_buf
->salt
;
12066 uint keccak_mdlen
= input_len
/ 2;
12068 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12070 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
12072 digest
[i
] = byte_swap_64 (digest
[i
]);
12075 salt
->keccak_mdlen
= keccak_mdlen
;
12077 return (PARSER_OK
);
12080 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12082 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12084 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12086 salt_t
*salt
= hash_buf
->salt
;
12088 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12091 * Parse that strange long line
12098 in_off
[0] = strtok (input_buf
, ":");
12100 in_len
[0] = strlen (in_off
[0]);
12104 for (i
= 1; i
< 9; i
++)
12106 in_off
[i
] = strtok (NULL
, ":");
12108 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12110 in_len
[i
] = strlen (in_off
[i
]);
12115 ptr
= (char *) ikepsk
->msg_buf
;
12117 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12118 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12119 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12120 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12121 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12122 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12126 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12128 ptr
= (char *) ikepsk
->nr_buf
;
12130 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12131 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12135 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12138 * Store to database
12143 digest
[0] = hex_to_uint (&ptr
[ 0]);
12144 digest
[1] = hex_to_uint (&ptr
[ 8]);
12145 digest
[2] = hex_to_uint (&ptr
[16]);
12146 digest
[3] = hex_to_uint (&ptr
[24]);
12148 digest
[0] = byte_swap_32 (digest
[0]);
12149 digest
[1] = byte_swap_32 (digest
[1]);
12150 digest
[2] = byte_swap_32 (digest
[2]);
12151 digest
[3] = byte_swap_32 (digest
[3]);
12153 salt
->salt_len
= 32;
12155 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12156 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12157 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12158 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12159 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12160 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12161 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12162 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12164 return (PARSER_OK
);
12167 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12169 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12171 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12173 salt_t
*salt
= hash_buf
->salt
;
12175 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12178 * Parse that strange long line
12185 in_off
[0] = strtok (input_buf
, ":");
12187 in_len
[0] = strlen (in_off
[0]);
12191 for (i
= 1; i
< 9; i
++)
12193 in_off
[i
] = strtok (NULL
, ":");
12195 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12197 in_len
[i
] = strlen (in_off
[i
]);
12202 ptr
= (char *) ikepsk
->msg_buf
;
12204 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12205 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12206 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12207 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12208 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12209 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12213 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12215 ptr
= (char *) ikepsk
->nr_buf
;
12217 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12218 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12222 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12225 * Store to database
12230 digest
[0] = hex_to_uint (&ptr
[ 0]);
12231 digest
[1] = hex_to_uint (&ptr
[ 8]);
12232 digest
[2] = hex_to_uint (&ptr
[16]);
12233 digest
[3] = hex_to_uint (&ptr
[24]);
12234 digest
[4] = hex_to_uint (&ptr
[32]);
12236 salt
->salt_len
= 32;
12238 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12239 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12240 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12241 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12242 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12243 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12244 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12245 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12247 return (PARSER_OK
);
12250 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12252 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12254 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12256 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12257 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12258 digest
[2] = hex_to_uint (&input_buf
[16]);
12259 digest
[3] = hex_to_uint (&input_buf
[24]);
12260 digest
[4] = hex_to_uint (&input_buf
[32]);
12262 digest
[0] = byte_swap_32 (digest
[0]);
12263 digest
[1] = byte_swap_32 (digest
[1]);
12264 digest
[2] = byte_swap_32 (digest
[2]);
12265 digest
[3] = byte_swap_32 (digest
[3]);
12266 digest
[4] = byte_swap_32 (digest
[4]);
12268 return (PARSER_OK
);
12271 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12273 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12275 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12277 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12278 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12279 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12280 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12281 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12282 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12283 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12284 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12285 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12286 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12287 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12288 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12289 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12290 digest
[13] = hex_to_uint (&input_buf
[104]);
12291 digest
[14] = hex_to_uint (&input_buf
[112]);
12292 digest
[15] = hex_to_uint (&input_buf
[120]);
12294 return (PARSER_OK
);
12297 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12299 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12301 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12303 salt_t
*salt
= hash_buf
->salt
;
12305 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12306 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12307 digest
[2] = hex_to_uint (&input_buf
[16]);
12308 digest
[3] = hex_to_uint (&input_buf
[24]);
12309 digest
[4] = hex_to_uint (&input_buf
[32]);
12311 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12313 uint salt_len
= input_len
- 40 - 1;
12315 char *salt_buf
= input_buf
+ 40 + 1;
12317 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12319 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12321 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12323 salt
->salt_len
= salt_len
;
12325 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12327 return (PARSER_OK
);
12330 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12332 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12334 salt_t
*salt
= hash_buf
->salt
;
12336 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12338 if (input_len
== 0)
12340 log_error ("TrueCrypt container not specified");
12345 FILE *fp
= fopen (input_buf
, "rb");
12349 log_error ("%s: %s", input_buf
, strerror (errno
));
12356 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12360 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12362 memcpy (tc
->salt_buf
, buf
, 64);
12364 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12366 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12368 salt
->salt_len
= 4;
12370 salt
->salt_iter
= 1000 - 1;
12372 digest
[0] = tc
->data_buf
[0];
12374 return (PARSER_OK
);
12377 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12381 salt_t
*salt
= hash_buf
->salt
;
12383 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12385 if (input_len
== 0)
12387 log_error ("TrueCrypt container not specified");
12392 FILE *fp
= fopen (input_buf
, "rb");
12396 log_error ("%s: %s", input_buf
, strerror (errno
));
12403 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12407 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12409 memcpy (tc
->salt_buf
, buf
, 64);
12411 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12413 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12415 salt
->salt_len
= 4;
12417 salt
->salt_iter
= 2000 - 1;
12419 digest
[0] = tc
->data_buf
[0];
12421 return (PARSER_OK
);
12424 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12426 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12428 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12430 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12432 salt_t
*salt
= hash_buf
->salt
;
12434 char *salt_pos
= input_buf
+ 6;
12436 char *hash_pos
= strchr (salt_pos
, '$');
12438 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12440 uint salt_len
= hash_pos
- salt_pos
;
12442 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12444 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12446 salt
->salt_len
= salt_len
;
12448 salt
->salt_iter
= 1000;
12452 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12454 return (PARSER_OK
);
12457 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12459 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12461 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12463 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12465 salt_t
*salt
= hash_buf
->salt
;
12467 char *iter_pos
= input_buf
+ 7;
12469 char *salt_pos
= strchr (iter_pos
, '$');
12471 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12475 char *hash_pos
= strchr (salt_pos
, '$');
12477 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12479 uint salt_len
= hash_pos
- salt_pos
;
12481 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12483 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12485 salt
->salt_len
= salt_len
;
12487 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12489 salt
->salt_sign
[0] = atoi (salt_iter
);
12491 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12495 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12497 digest
[0] = byte_swap_32 (digest
[0]);
12498 digest
[1] = byte_swap_32 (digest
[1]);
12499 digest
[2] = byte_swap_32 (digest
[2]);
12500 digest
[3] = byte_swap_32 (digest
[3]);
12501 digest
[4] = byte_swap_32 (digest
[4]);
12503 return (PARSER_OK
);
12506 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12508 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12510 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12512 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12514 salt_t
*salt
= hash_buf
->salt
;
12516 char *iter_pos
= input_buf
+ 9;
12518 char *salt_pos
= strchr (iter_pos
, '$');
12520 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12524 char *hash_pos
= strchr (salt_pos
, '$');
12526 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12528 uint salt_len
= hash_pos
- salt_pos
;
12530 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12532 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12534 salt
->salt_len
= salt_len
;
12536 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12538 salt
->salt_sign
[0] = atoi (salt_iter
);
12540 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12544 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12546 digest
[0] = byte_swap_32 (digest
[0]);
12547 digest
[1] = byte_swap_32 (digest
[1]);
12548 digest
[2] = byte_swap_32 (digest
[2]);
12549 digest
[3] = byte_swap_32 (digest
[3]);
12550 digest
[4] = byte_swap_32 (digest
[4]);
12551 digest
[5] = byte_swap_32 (digest
[5]);
12552 digest
[6] = byte_swap_32 (digest
[6]);
12553 digest
[7] = byte_swap_32 (digest
[7]);
12555 return (PARSER_OK
);
12558 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12560 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12562 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12564 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12566 salt_t
*salt
= hash_buf
->salt
;
12568 char *iter_pos
= input_buf
+ 9;
12570 char *salt_pos
= strchr (iter_pos
, '$');
12572 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12576 char *hash_pos
= strchr (salt_pos
, '$');
12578 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12580 uint salt_len
= hash_pos
- salt_pos
;
12582 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12584 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12586 salt
->salt_len
= salt_len
;
12588 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12590 salt
->salt_sign
[0] = atoi (salt_iter
);
12592 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12596 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12598 digest
[0] = byte_swap_64 (digest
[0]);
12599 digest
[1] = byte_swap_64 (digest
[1]);
12600 digest
[2] = byte_swap_64 (digest
[2]);
12601 digest
[3] = byte_swap_64 (digest
[3]);
12602 digest
[4] = byte_swap_64 (digest
[4]);
12603 digest
[5] = byte_swap_64 (digest
[5]);
12604 digest
[6] = byte_swap_64 (digest
[6]);
12605 digest
[7] = byte_swap_64 (digest
[7]);
12607 return (PARSER_OK
);
12610 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12612 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12614 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12616 salt_t
*salt
= hash_buf
->salt
;
12618 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12624 char *iterations_pos
= input_buf
;
12626 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12628 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12630 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12632 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12636 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12638 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12640 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12642 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12644 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12646 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12651 * pbkdf2 iterations
12654 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12657 * handle salt encoding
12660 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12662 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12664 const char p0
= saltbuf_pos
[i
+ 0];
12665 const char p1
= saltbuf_pos
[i
+ 1];
12667 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12668 | hex_convert (p0
) << 4;
12671 salt
->salt_len
= saltbuf_len
/ 2;
12674 * handle cipher encoding
12677 uint
*tmp
= (uint
*) mymalloc (32);
12679 char *cipherbuf_ptr
= (char *) tmp
;
12681 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12683 const char p0
= cipherbuf_pos
[i
+ 0];
12684 const char p1
= cipherbuf_pos
[i
+ 1];
12686 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12687 | hex_convert (p0
) << 4;
12690 // iv is stored at salt_buf 4 (length 16)
12691 // data is stored at salt_buf 8 (length 16)
12693 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12694 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12695 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12696 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12698 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12699 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12700 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12701 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12705 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12707 const char p0
= cipherbuf_pos
[j
+ 0];
12708 const char p1
= cipherbuf_pos
[j
+ 1];
12710 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12711 | hex_convert (p0
) << 4;
12718 digest
[0] = 0x10101010;
12719 digest
[1] = 0x10101010;
12720 digest
[2] = 0x10101010;
12721 digest
[3] = 0x10101010;
12723 return (PARSER_OK
);
12726 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12728 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12730 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12732 salt_t
*salt
= hash_buf
->salt
;
12734 char *hashbuf_pos
= input_buf
;
12736 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12738 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12740 uint hash_len
= iterations_pos
- hashbuf_pos
;
12742 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12746 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12748 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12750 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12754 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12756 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12758 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12760 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12762 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12764 salt
->salt_len
= salt_len
;
12766 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12768 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12769 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12770 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12771 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12773 return (PARSER_OK
);
12776 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12778 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12780 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12782 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12783 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12784 digest
[2] = hex_to_uint (&input_buf
[16]);
12785 digest
[3] = hex_to_uint (&input_buf
[24]);
12786 digest
[4] = hex_to_uint (&input_buf
[32]);
12787 digest
[5] = hex_to_uint (&input_buf
[40]);
12788 digest
[6] = hex_to_uint (&input_buf
[48]);
12789 digest
[7] = hex_to_uint (&input_buf
[56]);
12791 digest
[0] = byte_swap_32 (digest
[0]);
12792 digest
[1] = byte_swap_32 (digest
[1]);
12793 digest
[2] = byte_swap_32 (digest
[2]);
12794 digest
[3] = byte_swap_32 (digest
[3]);
12795 digest
[4] = byte_swap_32 (digest
[4]);
12796 digest
[5] = byte_swap_32 (digest
[5]);
12797 digest
[6] = byte_swap_32 (digest
[6]);
12798 digest
[7] = byte_swap_32 (digest
[7]);
12800 return (PARSER_OK
);
12803 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12805 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12807 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12809 salt_t
*salt
= hash_buf
->salt
;
12811 char *salt_pos
= input_buf
+ 3;
12813 uint iterations_len
= 0;
12815 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12819 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12821 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12822 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12826 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12830 iterations_len
+= 8;
12834 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12837 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12839 char *hash_pos
= strchr (salt_pos
, '$');
12841 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12843 uint salt_len
= hash_pos
- salt_pos
;
12845 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12847 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12849 salt
->salt_len
= salt_len
;
12853 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12855 return (PARSER_OK
);
12858 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12860 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12862 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12864 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12866 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12868 salt_t
*salt
= hash_buf
->salt
;
12870 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12872 char *iter_pos
= input_buf
+ 4;
12874 char *salt_pos
= strchr (iter_pos
, '$');
12876 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12880 char *hash_pos
= strchr (salt_pos
, '$');
12882 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12884 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12888 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12889 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12890 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12891 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12892 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12893 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12894 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12895 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12897 uint salt_len
= hash_pos
- salt_pos
- 1;
12899 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12901 salt
->salt_len
= salt_len
/ 2;
12903 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12904 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12905 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12906 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12907 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12908 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12909 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12910 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12912 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12913 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12914 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12915 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12916 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12917 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12918 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12919 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12920 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12921 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12923 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12925 salt
->salt_iter
= atoi (iter_pos
) - 1;
12927 return (PARSER_OK
);
12930 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12932 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12934 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12936 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12938 salt_t
*salt
= hash_buf
->salt
;
12940 char *salt_pos
= input_buf
+ 14;
12942 char *hash_pos
= strchr (salt_pos
, '*');
12944 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12948 uint salt_len
= hash_pos
- salt_pos
- 1;
12950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12956 salt
->salt_len
= salt_len
;
12958 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12960 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12962 memcpy (digest
, tmp_buf
, 32);
12964 digest
[0] = byte_swap_32 (digest
[0]);
12965 digest
[1] = byte_swap_32 (digest
[1]);
12966 digest
[2] = byte_swap_32 (digest
[2]);
12967 digest
[3] = byte_swap_32 (digest
[3]);
12968 digest
[4] = byte_swap_32 (digest
[4]);
12969 digest
[5] = byte_swap_32 (digest
[5]);
12970 digest
[6] = byte_swap_32 (digest
[6]);
12971 digest
[7] = byte_swap_32 (digest
[7]);
12973 digest
[0] -= SHA256M_A
;
12974 digest
[1] -= SHA256M_B
;
12975 digest
[2] -= SHA256M_C
;
12976 digest
[3] -= SHA256M_D
;
12977 digest
[4] -= SHA256M_E
;
12978 digest
[5] -= SHA256M_F
;
12979 digest
[6] -= SHA256M_G
;
12980 digest
[7] -= SHA256M_H
;
12982 return (PARSER_OK
);
12985 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12987 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12989 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12991 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12993 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12995 salt_t
*salt
= hash_buf
->salt
;
12997 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12999 char *iter_pos
= input_buf
+ 19;
13001 char *salt_pos
= strchr (iter_pos
, '.');
13003 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13007 char *hash_pos
= strchr (salt_pos
, '.');
13009 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13011 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13015 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
13016 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
13017 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
13018 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
13019 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
13020 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
13021 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
13022 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
13024 uint salt_len
= hash_pos
- salt_pos
- 1;
13028 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13032 for (i
= 0; i
< salt_len
; i
++)
13034 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
13037 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13038 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13040 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13042 salt
->salt_len
= salt_len
;
13044 salt
->salt_iter
= atoi (iter_pos
) - 1;
13046 return (PARSER_OK
);
13049 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13051 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13053 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13055 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13057 salt_t
*salt
= hash_buf
->salt
;
13061 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13063 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
13065 memcpy (digest
, tmp_buf
, 64);
13067 digest
[0] = byte_swap_64 (digest
[0]);
13068 digest
[1] = byte_swap_64 (digest
[1]);
13069 digest
[2] = byte_swap_64 (digest
[2]);
13070 digest
[3] = byte_swap_64 (digest
[3]);
13071 digest
[4] = byte_swap_64 (digest
[4]);
13072 digest
[5] = byte_swap_64 (digest
[5]);
13073 digest
[6] = byte_swap_64 (digest
[6]);
13074 digest
[7] = byte_swap_64 (digest
[7]);
13076 digest
[0] -= SHA512M_A
;
13077 digest
[1] -= SHA512M_B
;
13078 digest
[2] -= SHA512M_C
;
13079 digest
[3] -= SHA512M_D
;
13080 digest
[4] -= SHA512M_E
;
13081 digest
[5] -= SHA512M_F
;
13082 digest
[6] -= SHA512M_G
;
13083 digest
[7] -= SHA512M_H
;
13085 salt
->salt_len
= tmp_len
- 64;
13087 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13089 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13091 char *ptr
= (char *) salt
->salt_buf
;
13093 ptr
[salt
->salt_len
] = 0x80;
13096 return (PARSER_OK
);
13099 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13101 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13103 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13107 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13110 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13112 salt_t
*salt
= hash_buf
->salt
;
13114 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13115 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13116 digest
[2] = hex_to_uint (&input_buf
[16]);
13117 digest
[3] = hex_to_uint (&input_buf
[24]);
13119 digest
[0] = byte_swap_32 (digest
[0]);
13120 digest
[1] = byte_swap_32 (digest
[1]);
13121 digest
[2] = byte_swap_32 (digest
[2]);
13122 digest
[3] = byte_swap_32 (digest
[3]);
13124 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13126 uint salt_len
= input_len
- 32 - 1;
13128 char *salt_buf
= input_buf
+ 32 + 1;
13130 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13132 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13134 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13136 salt
->salt_len
= salt_len
;
13138 return (PARSER_OK
);
13141 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13143 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13145 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13149 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13152 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13154 salt_t
*salt
= hash_buf
->salt
;
13156 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13157 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13158 digest
[2] = hex_to_uint (&input_buf
[16]);
13159 digest
[3] = hex_to_uint (&input_buf
[24]);
13160 digest
[4] = hex_to_uint (&input_buf
[32]);
13162 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13164 uint salt_len
= input_len
- 40 - 1;
13166 char *salt_buf
= input_buf
+ 40 + 1;
13168 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13170 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13172 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13174 salt
->salt_len
= salt_len
;
13176 return (PARSER_OK
);
13179 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13181 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13183 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13187 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13190 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13192 salt_t
*salt
= hash_buf
->salt
;
13194 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13195 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13196 digest
[2] = hex_to_uint (&input_buf
[16]);
13197 digest
[3] = hex_to_uint (&input_buf
[24]);
13198 digest
[4] = hex_to_uint (&input_buf
[32]);
13199 digest
[5] = hex_to_uint (&input_buf
[40]);
13200 digest
[6] = hex_to_uint (&input_buf
[48]);
13201 digest
[7] = hex_to_uint (&input_buf
[56]);
13203 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13205 uint salt_len
= input_len
- 64 - 1;
13207 char *salt_buf
= input_buf
+ 64 + 1;
13209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13213 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13215 salt
->salt_len
= salt_len
;
13217 return (PARSER_OK
);
13220 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13222 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13224 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13228 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13231 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13233 salt_t
*salt
= hash_buf
->salt
;
13235 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13236 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13237 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13238 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13239 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13240 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13241 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13242 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13244 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13246 uint salt_len
= input_len
- 128 - 1;
13248 char *salt_buf
= input_buf
+ 128 + 1;
13250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13252 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13256 salt
->salt_len
= salt_len
;
13258 return (PARSER_OK
);
13261 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13263 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13265 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13267 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13269 salt_t
*salt
= hash_buf
->salt
;
13271 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13277 char *user_pos
= input_buf
+ 10 + 1;
13279 char *realm_pos
= strchr (user_pos
, '$');
13281 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13283 uint user_len
= realm_pos
- user_pos
;
13285 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13289 char *salt_pos
= strchr (realm_pos
, '$');
13291 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13293 uint realm_len
= salt_pos
- realm_pos
;
13295 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13299 char *data_pos
= strchr (salt_pos
, '$');
13301 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13303 uint salt_len
= data_pos
- salt_pos
;
13305 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13309 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13311 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13317 memcpy (krb5pa
->user
, user_pos
, user_len
);
13318 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13319 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13321 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13323 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13325 const char p0
= data_pos
[i
+ 0];
13326 const char p1
= data_pos
[i
+ 1];
13328 *timestamp_ptr
++ = hex_convert (p1
) << 0
13329 | hex_convert (p0
) << 4;
13332 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13334 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13336 const char p0
= data_pos
[i
+ 0];
13337 const char p1
= data_pos
[i
+ 1];
13339 *checksum_ptr
++ = hex_convert (p1
) << 0
13340 | hex_convert (p0
) << 4;
13344 * copy some data to generic buffers to make sorting happy
13347 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13348 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13349 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13350 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13351 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13352 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13353 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13354 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13355 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13357 salt
->salt_len
= 36;
13359 digest
[0] = krb5pa
->checksum
[0];
13360 digest
[1] = krb5pa
->checksum
[1];
13361 digest
[2] = krb5pa
->checksum
[2];
13362 digest
[3] = krb5pa
->checksum
[3];
13364 return (PARSER_OK
);
13367 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13369 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13371 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13373 salt_t
*salt
= hash_buf
->salt
;
13379 char *salt_pos
= input_buf
;
13381 char *hash_pos
= strchr (salt_pos
, '$');
13383 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13385 uint salt_len
= hash_pos
- salt_pos
;
13387 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13391 uint hash_len
= input_len
- 1 - salt_len
;
13393 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13401 for (uint i
= 0; i
< salt_len
; i
++)
13403 if (salt_pos
[i
] == ' ') continue;
13408 // SAP user names cannot be longer than 12 characters
13409 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13411 // SAP user name cannot start with ! or ?
13412 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13422 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13424 salt
->salt_len
= salt_len
;
13426 digest
[0] = hex_to_uint (&hash_pos
[0]);
13427 digest
[1] = hex_to_uint (&hash_pos
[8]);
13431 digest
[0] = byte_swap_32 (digest
[0]);
13432 digest
[1] = byte_swap_32 (digest
[1]);
13434 return (PARSER_OK
);
13437 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13439 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13441 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13443 salt_t
*salt
= hash_buf
->salt
;
13449 char *salt_pos
= input_buf
;
13451 char *hash_pos
= strchr (salt_pos
, '$');
13453 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13455 uint salt_len
= hash_pos
- salt_pos
;
13457 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13461 uint hash_len
= input_len
- 1 - salt_len
;
13463 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13471 for (uint i
= 0; i
< salt_len
; i
++)
13473 if (salt_pos
[i
] == ' ') continue;
13478 // SAP user names cannot be longer than 12 characters
13479 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13480 // so far nobody complained so we stay with this because it helps in optimization
13481 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13483 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13485 // SAP user name cannot start with ! or ?
13486 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13492 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13494 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13496 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13498 salt
->salt_len
= salt_len
;
13500 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13501 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13502 digest
[2] = hex_to_uint (&hash_pos
[16]);
13503 digest
[3] = hex_to_uint (&hash_pos
[24]);
13504 digest
[4] = hex_to_uint (&hash_pos
[32]);
13506 return (PARSER_OK
);
13509 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13511 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13513 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13515 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13517 salt_t
*salt
= hash_buf
->salt
;
13519 char *iter_pos
= input_buf
+ 3;
13521 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13523 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13525 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13527 salt
->salt_iter
= salt_iter
;
13529 char *salt_pos
= iter_pos
+ 1;
13533 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13535 salt
->salt_len
= salt_len
;
13537 char *hash_pos
= salt_pos
+ salt_len
;
13539 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13543 char *tmp
= (char *) salt
->salt_buf_pc
;
13545 tmp
[0] = hash_pos
[42];
13549 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13550 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13551 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13552 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13558 return (PARSER_OK
);
13561 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13563 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13565 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13567 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13569 salt_t
*salt
= hash_buf
->salt
;
13571 char *salt_buf
= input_buf
+ 6;
13573 uint salt_len
= 16;
13575 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13577 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13579 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13581 salt
->salt_len
= salt_len
;
13583 char *hash_pos
= input_buf
+ 6 + 16;
13585 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13586 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13587 digest
[2] = hex_to_uint (&hash_pos
[16]);
13588 digest
[3] = hex_to_uint (&hash_pos
[24]);
13589 digest
[4] = hex_to_uint (&hash_pos
[32]);
13590 digest
[5] = hex_to_uint (&hash_pos
[40]);
13591 digest
[6] = hex_to_uint (&hash_pos
[48]);
13592 digest
[7] = hex_to_uint (&hash_pos
[56]);
13594 return (PARSER_OK
);
13597 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13599 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13601 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13603 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13604 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13608 return (PARSER_OK
);
13611 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13613 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13615 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13617 salt_t
*salt
= hash_buf
->salt
;
13619 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13621 char *saltbuf_pos
= input_buf
;
13623 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13625 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13627 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13629 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13630 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13632 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13636 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13638 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13640 char *salt_ptr
= (char *) saltbuf_pos
;
13641 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13646 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13648 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13651 rakp_ptr
[j
] = 0x80;
13653 rakp
->salt_len
= j
;
13655 for (i
= 0; i
< 64; i
++)
13657 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13660 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13661 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13662 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13663 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13664 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13665 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13666 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13667 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13669 salt
->salt_len
= 32; // muss min. 32 haben
13671 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13672 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13673 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13674 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13675 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13677 return (PARSER_OK
);
13680 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13682 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13684 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13686 salt_t
*salt
= hash_buf
->salt
;
13688 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13690 char *salt_pos
= input_buf
+ 1;
13692 memcpy (salt
->salt_buf
, salt_pos
, 8);
13694 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13695 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13697 salt
->salt_len
= 8;
13699 char *hash_pos
= salt_pos
+ 8;
13701 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13702 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13703 digest
[2] = hex_to_uint (&hash_pos
[16]);
13704 digest
[3] = hex_to_uint (&hash_pos
[24]);
13705 digest
[4] = hex_to_uint (&hash_pos
[32]);
13707 digest
[0] -= SHA1M_A
;
13708 digest
[1] -= SHA1M_B
;
13709 digest
[2] -= SHA1M_C
;
13710 digest
[3] -= SHA1M_D
;
13711 digest
[4] -= SHA1M_E
;
13713 return (PARSER_OK
);
13716 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13718 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13720 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13722 salt_t
*salt
= hash_buf
->salt
;
13724 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13725 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13726 digest
[2] = hex_to_uint (&input_buf
[16]);
13727 digest
[3] = hex_to_uint (&input_buf
[24]);
13729 digest
[0] = byte_swap_32 (digest
[0]);
13730 digest
[1] = byte_swap_32 (digest
[1]);
13731 digest
[2] = byte_swap_32 (digest
[2]);
13732 digest
[3] = byte_swap_32 (digest
[3]);
13734 digest
[0] -= MD5M_A
;
13735 digest
[1] -= MD5M_B
;
13736 digest
[2] -= MD5M_C
;
13737 digest
[3] -= MD5M_D
;
13739 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13741 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13743 uint32_t *salt_buf
= salt
->salt_buf
;
13745 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13746 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13747 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13748 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13750 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13751 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13752 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13753 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13755 salt
->salt_len
= 16 + 1;
13757 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13759 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13761 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13763 return (PARSER_OK
);
13766 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13768 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13770 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13772 salt_t
*salt
= hash_buf
->salt
;
13774 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13780 char *hashbuf_pos
= input_buf
;
13782 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13784 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13786 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13788 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13792 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13794 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13796 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13798 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13802 char *databuf_pos
= strchr (iteration_pos
, ':');
13804 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13806 const uint iteration_len
= databuf_pos
- iteration_pos
;
13808 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13809 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13811 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13813 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13814 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13820 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13821 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13822 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13823 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13824 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13825 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13826 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13827 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13831 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13833 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13835 const char p0
= saltbuf_pos
[i
+ 0];
13836 const char p1
= saltbuf_pos
[i
+ 1];
13838 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13839 | hex_convert (p0
) << 4;
13842 salt
->salt_buf
[4] = 0x01000000;
13843 salt
->salt_buf
[5] = 0x80;
13845 salt
->salt_len
= saltbuf_len
/ 2;
13849 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13853 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13855 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13857 const char p0
= databuf_pos
[i
+ 0];
13858 const char p1
= databuf_pos
[i
+ 1];
13860 *databuf_ptr
++ = hex_convert (p1
) << 0
13861 | hex_convert (p0
) << 4;
13864 *databuf_ptr
++ = 0x80;
13866 for (uint i
= 0; i
< 512; i
++)
13868 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13871 cloudkey
->data_len
= databuf_len
/ 2;
13873 return (PARSER_OK
);
13876 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13878 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13880 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13882 salt_t
*salt
= hash_buf
->salt
;
13888 char *hashbuf_pos
= input_buf
;
13890 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13892 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13894 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13896 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13900 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13902 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13904 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13906 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13908 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13912 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13914 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13916 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13918 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13920 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13924 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13926 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13927 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13929 // ok, the plan for this algorithm is the following:
13930 // we have 2 salts here, the domain-name and a random salt
13931 // while both are used in the initial transformation,
13932 // only the random salt is used in the following iterations
13933 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13934 // and one that includes only the real salt (stored into salt_buf[]).
13935 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13937 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13939 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13941 memcpy (digest
, tmp_buf
, 20);
13943 digest
[0] = byte_swap_32 (digest
[0]);
13944 digest
[1] = byte_swap_32 (digest
[1]);
13945 digest
[2] = byte_swap_32 (digest
[2]);
13946 digest
[3] = byte_swap_32 (digest
[3]);
13947 digest
[4] = byte_swap_32 (digest
[4]);
13951 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13953 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13955 char *len_ptr
= NULL
;
13957 for (uint i
= 0; i
< domainbuf_len
; i
++)
13959 if (salt_buf_pc_ptr
[i
] == '.')
13961 len_ptr
= &salt_buf_pc_ptr
[i
];
13971 salt
->salt_buf_pc
[7] = domainbuf_len
;
13975 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13977 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13979 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13981 salt
->salt_len
= salt_len
;
13985 salt
->salt_iter
= atoi (iteration_pos
);
13987 return (PARSER_OK
);
13990 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13992 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13994 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13996 salt_t
*salt
= hash_buf
->salt
;
13998 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13999 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14000 digest
[2] = hex_to_uint (&input_buf
[16]);
14001 digest
[3] = hex_to_uint (&input_buf
[24]);
14002 digest
[4] = hex_to_uint (&input_buf
[32]);
14004 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14006 uint salt_len
= input_len
- 40 - 1;
14008 char *salt_buf
= input_buf
+ 40 + 1;
14010 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14012 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14014 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14016 salt
->salt_len
= salt_len
;
14018 return (PARSER_OK
);
14021 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14023 const uint8_t ascii_to_ebcdic
[] =
14025 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14026 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14027 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14028 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14029 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14030 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14031 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14032 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14033 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14034 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14035 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14036 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14037 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14038 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14039 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14040 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14043 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14045 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14047 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14049 salt_t
*salt
= hash_buf
->salt
;
14051 char *salt_pos
= input_buf
+ 6 + 1;
14053 char *digest_pos
= strchr (salt_pos
, '*');
14055 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14057 uint salt_len
= digest_pos
- salt_pos
;
14059 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14061 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14063 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14068 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14070 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14072 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14074 salt
->salt_len
= salt_len
;
14076 for (uint i
= 0; i
< salt_len
; i
++)
14078 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14080 for (uint i
= salt_len
; i
< 8; i
++)
14082 salt_buf_pc_ptr
[i
] = 0x40;
14087 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14089 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
14090 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
14092 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
14093 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
14095 digest
[0] = byte_swap_32 (digest
[0]);
14096 digest
[1] = byte_swap_32 (digest
[1]);
14098 IP (digest
[0], digest
[1], tt
);
14100 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
14101 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
14105 return (PARSER_OK
);
14108 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14110 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14112 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14114 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14115 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14116 digest
[2] = hex_to_uint (&input_buf
[16]);
14117 digest
[3] = hex_to_uint (&input_buf
[24]);
14119 digest
[0] = byte_swap_32 (digest
[0]);
14120 digest
[1] = byte_swap_32 (digest
[1]);
14121 digest
[2] = byte_swap_32 (digest
[2]);
14122 digest
[3] = byte_swap_32 (digest
[3]);
14124 return (PARSER_OK
);
14127 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14129 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14131 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14133 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14135 salt_t
*salt
= hash_buf
->salt
;
14139 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14141 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14143 tmp_buf
[3] += -4; // dont ask!
14145 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14147 salt
->salt_len
= 5;
14149 memcpy (digest
, tmp_buf
+ 5, 9);
14151 // yes, only 9 byte are needed to crack, but 10 to display
14153 salt
->salt_buf_pc
[7] = input_buf
[20];
14155 return (PARSER_OK
);
14158 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14160 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14162 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14164 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14166 salt_t
*salt
= hash_buf
->salt
;
14170 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14172 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14174 tmp_buf
[3] += -4; // dont ask!
14178 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14180 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)
14184 char tmp_iter_buf
[11];
14186 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14188 tmp_iter_buf
[10] = 0;
14190 salt
->salt_iter
= atoi (tmp_iter_buf
);
14192 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14194 return (PARSER_SALT_ITERATION
);
14197 salt
->salt_iter
--; // first round in init
14199 // 2 additional bytes for display only
14201 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14202 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14206 memcpy (digest
, tmp_buf
+ 28, 8);
14208 digest
[0] = byte_swap_32 (digest
[0]);
14209 digest
[1] = byte_swap_32 (digest
[1]);
14213 return (PARSER_OK
);
14216 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14218 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14220 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14222 salt_t
*salt
= hash_buf
->salt
;
14224 char *salt_buf_pos
= input_buf
;
14226 char *hash_buf_pos
= salt_buf_pos
+ 6;
14228 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14229 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14230 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14231 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14232 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14233 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14234 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14235 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14237 digest
[0] -= SHA256M_A
;
14238 digest
[1] -= SHA256M_B
;
14239 digest
[2] -= SHA256M_C
;
14240 digest
[3] -= SHA256M_D
;
14241 digest
[4] -= SHA256M_E
;
14242 digest
[5] -= SHA256M_F
;
14243 digest
[6] -= SHA256M_G
;
14244 digest
[7] -= SHA256M_H
;
14246 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14248 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14250 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14252 salt
->salt_len
= salt_len
;
14254 return (PARSER_OK
);
14257 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14259 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14261 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14263 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14265 salt_t
*salt
= hash_buf
->salt
;
14267 char *salt_buf
= input_buf
+ 6;
14269 char *digest_buf
= strchr (salt_buf
, '$');
14271 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14273 uint salt_len
= digest_buf
- salt_buf
;
14275 digest_buf
++; // skip the '$' symbol
14277 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14283 salt
->salt_len
= salt_len
;
14285 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14286 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14287 digest
[2] = hex_to_uint (&digest_buf
[16]);
14288 digest
[3] = hex_to_uint (&digest_buf
[24]);
14290 digest
[0] = byte_swap_32 (digest
[0]);
14291 digest
[1] = byte_swap_32 (digest
[1]);
14292 digest
[2] = byte_swap_32 (digest
[2]);
14293 digest
[3] = byte_swap_32 (digest
[3]);
14295 digest
[0] -= MD5M_A
;
14296 digest
[1] -= MD5M_B
;
14297 digest
[2] -= MD5M_C
;
14298 digest
[3] -= MD5M_D
;
14300 return (PARSER_OK
);
14303 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14305 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14307 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14309 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14311 salt_t
*salt
= hash_buf
->salt
;
14313 char *salt_buf
= input_buf
+ 3;
14315 char *digest_buf
= strchr (salt_buf
, '$');
14317 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14319 uint salt_len
= digest_buf
- salt_buf
;
14321 digest_buf
++; // skip the '$' symbol
14323 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14325 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14327 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14329 salt_buf_ptr
[salt_len
] = 0x2d;
14331 salt
->salt_len
= salt_len
+ 1;
14333 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14334 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14335 digest
[2] = hex_to_uint (&digest_buf
[16]);
14336 digest
[3] = hex_to_uint (&digest_buf
[24]);
14338 digest
[0] = byte_swap_32 (digest
[0]);
14339 digest
[1] = byte_swap_32 (digest
[1]);
14340 digest
[2] = byte_swap_32 (digest
[2]);
14341 digest
[3] = byte_swap_32 (digest
[3]);
14343 digest
[0] -= MD5M_A
;
14344 digest
[1] -= MD5M_B
;
14345 digest
[2] -= MD5M_C
;
14346 digest
[3] -= MD5M_D
;
14348 return (PARSER_OK
);
14351 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14353 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14355 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14359 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14361 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14363 memcpy (digest
, tmp_buf
, 20);
14365 digest
[0] = byte_swap_32 (digest
[0]);
14366 digest
[1] = byte_swap_32 (digest
[1]);
14367 digest
[2] = byte_swap_32 (digest
[2]);
14368 digest
[3] = byte_swap_32 (digest
[3]);
14369 digest
[4] = byte_swap_32 (digest
[4]);
14371 digest
[0] -= SHA1M_A
;
14372 digest
[1] -= SHA1M_B
;
14373 digest
[2] -= SHA1M_C
;
14374 digest
[3] -= SHA1M_D
;
14375 digest
[4] -= SHA1M_E
;
14377 return (PARSER_OK
);
14380 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14382 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14384 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14386 salt_t
*salt
= hash_buf
->salt
;
14388 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14389 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14390 digest
[2] = hex_to_uint (&input_buf
[16]);
14391 digest
[3] = hex_to_uint (&input_buf
[24]);
14393 digest
[0] = byte_swap_32 (digest
[0]);
14394 digest
[1] = byte_swap_32 (digest
[1]);
14395 digest
[2] = byte_swap_32 (digest
[2]);
14396 digest
[3] = byte_swap_32 (digest
[3]);
14398 digest
[0] -= MD5M_A
;
14399 digest
[1] -= MD5M_B
;
14400 digest
[2] -= MD5M_C
;
14401 digest
[3] -= MD5M_D
;
14403 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14405 uint salt_len
= input_len
- 32 - 1;
14407 char *salt_buf
= input_buf
+ 32 + 1;
14409 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14411 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14413 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14416 * add static "salt" part
14419 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14423 salt
->salt_len
= salt_len
;
14425 return (PARSER_OK
);
14428 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14430 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14432 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14434 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14436 salt_t
*salt
= hash_buf
->salt
;
14438 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14444 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14446 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14448 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14450 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14452 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14456 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14458 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14460 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14462 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14466 char *keybuf_pos
= strchr (keylen_pos
, '$');
14468 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14470 uint keylen_len
= keybuf_pos
- keylen_pos
;
14472 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14476 char *databuf_pos
= strchr (keybuf_pos
, '$');
14478 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14480 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14482 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14486 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14488 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14494 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14495 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14496 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14497 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14499 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14500 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14501 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14502 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14504 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14505 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14506 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14507 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14509 salt
->salt_len
= 16;
14510 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14512 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14514 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14517 return (PARSER_OK
);
14520 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14522 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14524 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14526 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14528 salt_t
*salt
= hash_buf
->salt
;
14534 // first is the N salt parameter
14536 char *N_pos
= input_buf
+ 6;
14538 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14542 salt
->scrypt_N
= atoi (N_pos
);
14546 char *r_pos
= strchr (N_pos
, ':');
14548 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14552 salt
->scrypt_r
= atoi (r_pos
);
14556 char *p_pos
= strchr (r_pos
, ':');
14558 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14562 salt
->scrypt_p
= atoi (p_pos
);
14566 char *saltbuf_pos
= strchr (p_pos
, ':');
14568 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14572 char *hash_pos
= strchr (saltbuf_pos
, ':');
14574 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14582 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14584 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14586 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14588 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14590 salt
->salt_len
= tmp_len
;
14591 salt
->salt_iter
= 1;
14593 // digest - base64 decode
14595 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14597 tmp_len
= input_len
- (hash_pos
- input_buf
);
14599 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14601 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14603 memcpy (digest
, tmp_buf
, 32);
14605 return (PARSER_OK
);
14608 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14610 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14612 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14614 salt_t
*salt
= hash_buf
->salt
;
14620 char decrypted
[76]; // iv + hash
14622 juniper_decrypt_hash (input_buf
, decrypted
);
14624 char *md5crypt_hash
= decrypted
+ 12;
14626 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14628 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14630 char *salt_pos
= md5crypt_hash
+ 3;
14632 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14634 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14636 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14640 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14642 return (PARSER_OK
);
14645 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14647 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14649 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14651 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14653 salt_t
*salt
= hash_buf
->salt
;
14655 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14661 // first is *raw* salt
14663 char *salt_pos
= input_buf
+ 3;
14665 char *hash_pos
= strchr (salt_pos
, '$');
14667 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14669 uint salt_len
= hash_pos
- salt_pos
;
14671 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14675 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14677 memcpy (salt_buf_ptr
, salt_pos
, 14);
14679 salt_buf_ptr
[17] = 0x01;
14680 salt_buf_ptr
[18] = 0x80;
14682 // add some stuff to normal salt to make sorted happy
14684 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14685 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14686 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14687 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14689 salt
->salt_len
= salt_len
;
14690 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14692 // base64 decode hash
14696 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14698 uint hash_len
= input_len
- 3 - salt_len
- 1;
14700 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14702 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14704 memcpy (digest
, tmp_buf
, 32);
14706 digest
[0] = byte_swap_32 (digest
[0]);
14707 digest
[1] = byte_swap_32 (digest
[1]);
14708 digest
[2] = byte_swap_32 (digest
[2]);
14709 digest
[3] = byte_swap_32 (digest
[3]);
14710 digest
[4] = byte_swap_32 (digest
[4]);
14711 digest
[5] = byte_swap_32 (digest
[5]);
14712 digest
[6] = byte_swap_32 (digest
[6]);
14713 digest
[7] = byte_swap_32 (digest
[7]);
14715 return (PARSER_OK
);
14718 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14720 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14722 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14724 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14726 salt_t
*salt
= hash_buf
->salt
;
14732 // first is *raw* salt
14734 char *salt_pos
= input_buf
+ 3;
14736 char *hash_pos
= strchr (salt_pos
, '$');
14738 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14740 uint salt_len
= hash_pos
- salt_pos
;
14742 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14744 salt
->salt_len
= salt_len
;
14747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14749 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14750 salt_buf_ptr
[salt_len
] = 0;
14752 // base64 decode hash
14756 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14758 uint hash_len
= input_len
- 3 - salt_len
- 1;
14760 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14762 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14764 memcpy (digest
, tmp_buf
, 32);
14767 salt
->scrypt_N
= 16384;
14768 salt
->scrypt_r
= 1;
14769 salt
->scrypt_p
= 1;
14770 salt
->salt_iter
= 1;
14772 return (PARSER_OK
);
14775 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14777 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14779 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14781 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14783 salt_t
*salt
= hash_buf
->salt
;
14785 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14791 char *version_pos
= input_buf
+ 8 + 1;
14793 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14795 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14797 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14799 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14801 verifierHashSize_pos
++;
14803 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14805 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14807 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14809 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14813 char *saltSize_pos
= strchr (keySize_pos
, '*');
14815 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14817 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14819 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14823 char *osalt_pos
= strchr (saltSize_pos
, '*');
14825 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14827 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14829 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14833 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14835 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14837 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14839 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14841 encryptedVerifier_pos
++;
14843 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14845 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14847 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14849 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14851 encryptedVerifierHash_pos
++;
14853 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;
14855 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14857 const uint version
= atoi (version_pos
);
14859 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14861 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14863 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14865 const uint keySize
= atoi (keySize_pos
);
14867 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14869 office2007
->keySize
= keySize
;
14871 const uint saltSize
= atoi (saltSize_pos
);
14873 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14879 salt
->salt_len
= 16;
14880 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14882 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14883 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14884 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14885 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14891 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14892 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14893 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14894 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14896 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14897 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14898 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14899 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14900 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14906 digest
[0] = office2007
->encryptedVerifierHash
[0];
14907 digest
[1] = office2007
->encryptedVerifierHash
[1];
14908 digest
[2] = office2007
->encryptedVerifierHash
[2];
14909 digest
[3] = office2007
->encryptedVerifierHash
[3];
14911 return (PARSER_OK
);
14914 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14916 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14918 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14920 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14922 salt_t
*salt
= hash_buf
->salt
;
14924 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14930 char *version_pos
= input_buf
+ 8 + 1;
14932 char *spinCount_pos
= strchr (version_pos
, '*');
14934 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14936 uint32_t version_len
= spinCount_pos
- version_pos
;
14938 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14942 char *keySize_pos
= strchr (spinCount_pos
, '*');
14944 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14946 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14948 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14952 char *saltSize_pos
= strchr (keySize_pos
, '*');
14954 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14958 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14962 char *osalt_pos
= strchr (saltSize_pos
, '*');
14964 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14966 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14968 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14972 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14974 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14976 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14978 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14980 encryptedVerifier_pos
++;
14982 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14984 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14986 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14988 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14990 encryptedVerifierHash_pos
++;
14992 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;
14994 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14996 const uint version
= atoi (version_pos
);
14998 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15000 const uint spinCount
= atoi (spinCount_pos
);
15002 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15004 const uint keySize
= atoi (keySize_pos
);
15006 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15008 const uint saltSize
= atoi (saltSize_pos
);
15010 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15016 salt
->salt_len
= 16;
15017 salt
->salt_iter
= spinCount
;
15019 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15020 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15021 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15022 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15028 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15029 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15030 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15031 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15033 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15034 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15035 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15036 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15037 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15038 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15039 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15040 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15046 digest
[0] = office2010
->encryptedVerifierHash
[0];
15047 digest
[1] = office2010
->encryptedVerifierHash
[1];
15048 digest
[2] = office2010
->encryptedVerifierHash
[2];
15049 digest
[3] = office2010
->encryptedVerifierHash
[3];
15051 return (PARSER_OK
);
15054 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15056 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15058 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15060 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15062 salt_t
*salt
= hash_buf
->salt
;
15064 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15070 char *version_pos
= input_buf
+ 8 + 1;
15072 char *spinCount_pos
= strchr (version_pos
, '*');
15074 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15076 uint32_t version_len
= spinCount_pos
- version_pos
;
15078 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15082 char *keySize_pos
= strchr (spinCount_pos
, '*');
15084 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15086 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
15088 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15092 char *saltSize_pos
= strchr (keySize_pos
, '*');
15094 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15096 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
15098 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15102 char *osalt_pos
= strchr (saltSize_pos
, '*');
15104 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15106 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
15108 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15112 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15114 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15116 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15118 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15120 encryptedVerifier_pos
++;
15122 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15124 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15126 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15128 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15130 encryptedVerifierHash_pos
++;
15132 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;
15134 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15136 const uint version
= atoi (version_pos
);
15138 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15140 const uint spinCount
= atoi (spinCount_pos
);
15142 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15144 const uint keySize
= atoi (keySize_pos
);
15146 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15148 const uint saltSize
= atoi (saltSize_pos
);
15150 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15156 salt
->salt_len
= 16;
15157 salt
->salt_iter
= spinCount
;
15159 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15160 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15161 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15162 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15168 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15169 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15170 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15171 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15173 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15174 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15175 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15176 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15177 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15178 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15179 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15180 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15186 digest
[0] = office2013
->encryptedVerifierHash
[0];
15187 digest
[1] = office2013
->encryptedVerifierHash
[1];
15188 digest
[2] = office2013
->encryptedVerifierHash
[2];
15189 digest
[3] = office2013
->encryptedVerifierHash
[3];
15191 return (PARSER_OK
);
15194 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15196 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15198 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15200 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15202 salt_t
*salt
= hash_buf
->salt
;
15204 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15210 char *version_pos
= input_buf
+ 11;
15212 char *osalt_pos
= strchr (version_pos
, '*');
15214 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15216 uint32_t version_len
= osalt_pos
- version_pos
;
15218 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15222 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15224 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15226 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15228 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15230 encryptedVerifier_pos
++;
15232 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15234 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15236 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15238 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15240 encryptedVerifierHash_pos
++;
15242 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15244 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15246 const uint version
= *version_pos
- 0x30;
15248 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15254 oldoffice01
->version
= version
;
15256 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15257 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15258 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15259 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15261 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15262 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15263 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15264 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15266 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15267 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15268 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15269 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15271 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15272 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15273 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15274 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15280 salt
->salt_len
= 16;
15282 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15283 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15284 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15285 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15287 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15288 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15289 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15290 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15292 // this is a workaround as office produces multiple documents with the same salt
15294 salt
->salt_len
+= 32;
15296 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15297 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15298 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15299 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15300 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15301 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15302 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15303 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15309 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15310 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15311 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15312 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15314 return (PARSER_OK
);
15317 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15319 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15322 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15324 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15326 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15328 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15330 salt_t
*salt
= hash_buf
->salt
;
15332 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15338 char *version_pos
= input_buf
+ 11;
15340 char *osalt_pos
= strchr (version_pos
, '*');
15342 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15344 uint32_t version_len
= osalt_pos
- version_pos
;
15346 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15350 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15352 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15354 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15356 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15358 encryptedVerifier_pos
++;
15360 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15362 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15364 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15366 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15368 encryptedVerifierHash_pos
++;
15370 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15372 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15374 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15376 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15380 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15382 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15384 const uint version
= *version_pos
- 0x30;
15386 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15392 oldoffice01
->version
= version
;
15394 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15395 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15396 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15397 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15399 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15400 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15401 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15402 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15404 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15405 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15406 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15407 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15409 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15410 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15411 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15412 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15414 oldoffice01
->rc4key
[1] = 0;
15415 oldoffice01
->rc4key
[0] = 0;
15417 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15418 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15419 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15420 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15421 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15422 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15423 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15424 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15425 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15426 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15428 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15429 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15435 salt
->salt_len
= 16;
15437 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15438 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15439 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15440 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15442 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15443 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15444 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15445 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15447 // this is a workaround as office produces multiple documents with the same salt
15449 salt
->salt_len
+= 32;
15451 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15452 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15453 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15454 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15455 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15456 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15457 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15458 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15464 digest
[0] = oldoffice01
->rc4key
[0];
15465 digest
[1] = oldoffice01
->rc4key
[1];
15469 return (PARSER_OK
);
15472 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15474 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15476 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15478 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15480 salt_t
*salt
= hash_buf
->salt
;
15482 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15488 char *version_pos
= input_buf
+ 11;
15490 char *osalt_pos
= strchr (version_pos
, '*');
15492 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15494 uint32_t version_len
= osalt_pos
- version_pos
;
15496 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15500 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15502 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15504 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15506 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15508 encryptedVerifier_pos
++;
15510 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15512 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15514 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15516 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15518 encryptedVerifierHash_pos
++;
15520 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15522 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15524 const uint version
= *version_pos
- 0x30;
15526 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15532 oldoffice34
->version
= version
;
15534 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15535 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15536 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15537 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15539 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15540 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15541 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15542 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15544 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15545 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15546 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15547 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15548 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15550 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15551 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15552 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15553 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15554 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15560 salt
->salt_len
= 16;
15562 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15563 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15564 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15565 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15567 // this is a workaround as office produces multiple documents with the same salt
15569 salt
->salt_len
+= 32;
15571 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15572 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15573 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15574 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15575 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15576 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15577 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15578 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15584 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15585 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15586 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15587 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15589 return (PARSER_OK
);
15592 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15594 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15596 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15599 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15601 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15603 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15605 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15607 salt_t
*salt
= hash_buf
->salt
;
15609 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15615 char *version_pos
= input_buf
+ 11;
15617 char *osalt_pos
= strchr (version_pos
, '*');
15619 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15621 uint32_t version_len
= osalt_pos
- version_pos
;
15623 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15627 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15629 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15631 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15633 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15635 encryptedVerifier_pos
++;
15637 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15639 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15641 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15643 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15645 encryptedVerifierHash_pos
++;
15647 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15649 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15651 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15653 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15657 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15659 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15661 const uint version
= *version_pos
- 0x30;
15663 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15669 oldoffice34
->version
= version
;
15671 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15672 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15673 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15674 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15676 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15677 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15678 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15679 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15681 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15682 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15683 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15684 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15685 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15687 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15688 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15689 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15690 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15691 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15693 oldoffice34
->rc4key
[1] = 0;
15694 oldoffice34
->rc4key
[0] = 0;
15696 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15697 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15698 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15699 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15700 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15701 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15702 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15703 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15704 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15705 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15707 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15708 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15714 salt
->salt_len
= 16;
15716 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15717 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15718 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15719 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15721 // this is a workaround as office produces multiple documents with the same salt
15723 salt
->salt_len
+= 32;
15725 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15726 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15727 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15728 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15729 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15730 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15731 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15732 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15738 digest
[0] = oldoffice34
->rc4key
[0];
15739 digest
[1] = oldoffice34
->rc4key
[1];
15743 return (PARSER_OK
);
15746 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15748 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15750 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15752 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15753 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15754 digest
[2] = hex_to_uint (&input_buf
[16]);
15755 digest
[3] = hex_to_uint (&input_buf
[24]);
15757 digest
[0] = byte_swap_32 (digest
[0]);
15758 digest
[1] = byte_swap_32 (digest
[1]);
15759 digest
[2] = byte_swap_32 (digest
[2]);
15760 digest
[3] = byte_swap_32 (digest
[3]);
15762 return (PARSER_OK
);
15765 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15767 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15769 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15771 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15773 salt_t
*salt
= hash_buf
->salt
;
15775 char *signature_pos
= input_buf
;
15777 char *salt_pos
= strchr (signature_pos
, '$');
15779 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15781 uint32_t signature_len
= salt_pos
- signature_pos
;
15783 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15787 char *hash_pos
= strchr (salt_pos
, '$');
15789 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15791 uint32_t salt_len
= hash_pos
- salt_pos
;
15793 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15797 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15799 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15801 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15802 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15803 digest
[2] = hex_to_uint (&hash_pos
[16]);
15804 digest
[3] = hex_to_uint (&hash_pos
[24]);
15805 digest
[4] = hex_to_uint (&hash_pos
[32]);
15807 digest
[0] -= SHA1M_A
;
15808 digest
[1] -= SHA1M_B
;
15809 digest
[2] -= SHA1M_C
;
15810 digest
[3] -= SHA1M_D
;
15811 digest
[4] -= SHA1M_E
;
15813 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15815 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15817 salt
->salt_len
= salt_len
;
15819 return (PARSER_OK
);
15822 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15824 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15826 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15828 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15830 salt_t
*salt
= hash_buf
->salt
;
15832 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15838 char *iter_pos
= input_buf
+ 14;
15840 const int iter
= atoi (iter_pos
);
15842 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15844 salt
->salt_iter
= iter
- 1;
15846 char *salt_pos
= strchr (iter_pos
, '$');
15848 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15852 char *hash_pos
= strchr (salt_pos
, '$');
15854 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15856 const uint salt_len
= hash_pos
- salt_pos
;
15860 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15862 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15864 salt
->salt_len
= salt_len
;
15866 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15867 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15869 // add some stuff to normal salt to make sorted happy
15871 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15872 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15873 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15874 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15875 salt
->salt_buf
[4] = salt
->salt_iter
;
15877 // base64 decode hash
15881 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15883 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15885 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15887 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15889 memcpy (digest
, tmp_buf
, 32);
15891 digest
[0] = byte_swap_32 (digest
[0]);
15892 digest
[1] = byte_swap_32 (digest
[1]);
15893 digest
[2] = byte_swap_32 (digest
[2]);
15894 digest
[3] = byte_swap_32 (digest
[3]);
15895 digest
[4] = byte_swap_32 (digest
[4]);
15896 digest
[5] = byte_swap_32 (digest
[5]);
15897 digest
[6] = byte_swap_32 (digest
[6]);
15898 digest
[7] = byte_swap_32 (digest
[7]);
15900 return (PARSER_OK
);
15903 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15905 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15907 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15909 salt_t
*salt
= hash_buf
->salt
;
15911 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15912 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15916 digest
[0] = byte_swap_32 (digest
[0]);
15917 digest
[1] = byte_swap_32 (digest
[1]);
15919 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15920 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15921 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15923 char iter_c
= input_buf
[17];
15924 char iter_d
= input_buf
[19];
15926 // atm only defaults, let's see if there's more request
15927 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15928 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15930 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15932 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15933 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15934 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15935 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15937 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15938 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15939 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15940 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15942 salt
->salt_len
= 16;
15944 return (PARSER_OK
);
15947 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15949 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15951 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15953 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15955 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15957 salt_t
*salt
= hash_buf
->salt
;
15959 char *salt_pos
= input_buf
+ 10;
15961 char *hash_pos
= strchr (salt_pos
, '$');
15963 uint salt_len
= hash_pos
- salt_pos
;
15965 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15969 uint hash_len
= input_len
- 10 - salt_len
- 1;
15971 // base64 decode salt
15975 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15977 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15979 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15981 tmp_buf
[salt_len
] = 0x80;
15983 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15985 salt
->salt_len
= salt_len
;
15987 // base64 decode salt
15989 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15991 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15993 uint user_len
= hash_len
- 32;
15995 char *tmp_hash
= tmp_buf
+ user_len
;
15997 user_len
--; // skip the trailing space
15999 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
16000 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
16001 digest
[2] = hex_to_uint (&tmp_hash
[16]);
16002 digest
[3] = hex_to_uint (&tmp_hash
[24]);
16004 digest
[0] = byte_swap_32 (digest
[0]);
16005 digest
[1] = byte_swap_32 (digest
[1]);
16006 digest
[2] = byte_swap_32 (digest
[2]);
16007 digest
[3] = byte_swap_32 (digest
[3]);
16009 // store username for host only (output hash if cracked)
16011 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16012 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16014 return (PARSER_OK
);
16017 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16019 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16021 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16023 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16025 salt_t
*salt
= hash_buf
->salt
;
16027 char *iter_pos
= input_buf
+ 10;
16029 uint32_t iter
= atoi (iter_pos
);
16033 return (PARSER_SALT_ITERATION
);
16036 iter
--; // first iteration is special
16038 salt
->salt_iter
= iter
;
16040 char *base64_pos
= strchr (iter_pos
, '}');
16042 if (base64_pos
== NULL
)
16044 return (PARSER_SIGNATURE_UNMATCHED
);
16049 // base64 decode salt
16051 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
16055 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16057 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
16059 if (decoded_len
< 24)
16061 return (PARSER_SALT_LENGTH
);
16066 uint salt_len
= decoded_len
- 20;
16068 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16069 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16071 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16073 salt
->salt_len
= salt_len
;
16077 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
16079 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16080 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16081 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16082 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16083 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16085 return (PARSER_OK
);
16088 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16090 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16092 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16094 salt_t
*salt
= hash_buf
->salt
;
16096 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16097 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16098 digest
[2] = hex_to_uint (&input_buf
[16]);
16099 digest
[3] = hex_to_uint (&input_buf
[24]);
16100 digest
[4] = hex_to_uint (&input_buf
[32]);
16102 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16104 uint salt_len
= input_len
- 40 - 1;
16106 char *salt_buf
= input_buf
+ 40 + 1;
16108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16112 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16114 salt
->salt_len
= salt_len
;
16116 return (PARSER_OK
);
16119 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16121 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16123 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16125 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16127 salt_t
*salt
= hash_buf
->salt
;
16129 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16135 char *V_pos
= input_buf
+ 5;
16137 char *R_pos
= strchr (V_pos
, '*');
16139 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16141 uint32_t V_len
= R_pos
- V_pos
;
16145 char *bits_pos
= strchr (R_pos
, '*');
16147 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16149 uint32_t R_len
= bits_pos
- R_pos
;
16153 char *P_pos
= strchr (bits_pos
, '*');
16155 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16157 uint32_t bits_len
= P_pos
- bits_pos
;
16161 char *enc_md_pos
= strchr (P_pos
, '*');
16163 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16165 uint32_t P_len
= enc_md_pos
- P_pos
;
16169 char *id_len_pos
= strchr (enc_md_pos
, '*');
16171 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16173 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16177 char *id_buf_pos
= strchr (id_len_pos
, '*');
16179 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16181 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16185 char *u_len_pos
= strchr (id_buf_pos
, '*');
16187 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16189 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16191 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16195 char *u_buf_pos
= strchr (u_len_pos
, '*');
16197 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16199 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16203 char *o_len_pos
= strchr (u_buf_pos
, '*');
16205 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16207 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16209 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16213 char *o_buf_pos
= strchr (o_len_pos
, '*');
16215 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16217 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16221 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;
16223 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16227 const int V
= atoi (V_pos
);
16228 const int R
= atoi (R_pos
);
16229 const int P
= atoi (P_pos
);
16231 if (V
!= 1) return (PARSER_SALT_VALUE
);
16232 if (R
!= 2) return (PARSER_SALT_VALUE
);
16234 const int enc_md
= atoi (enc_md_pos
);
16236 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16238 const int id_len
= atoi (id_len_pos
);
16239 const int u_len
= atoi (u_len_pos
);
16240 const int o_len
= atoi (o_len_pos
);
16242 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16243 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16244 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16246 const int bits
= atoi (bits_pos
);
16248 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16250 // copy data to esalt
16256 pdf
->enc_md
= enc_md
;
16258 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16259 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16260 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16261 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16262 pdf
->id_len
= id_len
;
16264 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16265 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16266 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16267 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16268 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16269 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16270 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16271 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16272 pdf
->u_len
= u_len
;
16274 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16275 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16276 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16277 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16278 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16279 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16280 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16281 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16282 pdf
->o_len
= o_len
;
16284 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16285 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16286 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16287 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16289 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16290 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16291 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16292 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16293 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16294 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16295 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16296 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16298 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16299 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16300 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16301 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16302 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16303 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16304 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16305 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16307 // we use ID for salt, maybe needs to change, we will see...
16309 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16310 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16311 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16312 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16313 salt
->salt_len
= pdf
->id_len
;
16315 digest
[0] = pdf
->u_buf
[0];
16316 digest
[1] = pdf
->u_buf
[1];
16317 digest
[2] = pdf
->u_buf
[2];
16318 digest
[3] = pdf
->u_buf
[3];
16320 return (PARSER_OK
);
16323 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16325 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16328 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16330 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16332 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16334 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16336 salt_t
*salt
= hash_buf
->salt
;
16338 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16344 char *V_pos
= input_buf
+ 5;
16346 char *R_pos
= strchr (V_pos
, '*');
16348 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16350 uint32_t V_len
= R_pos
- V_pos
;
16354 char *bits_pos
= strchr (R_pos
, '*');
16356 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16358 uint32_t R_len
= bits_pos
- R_pos
;
16362 char *P_pos
= strchr (bits_pos
, '*');
16364 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16366 uint32_t bits_len
= P_pos
- bits_pos
;
16370 char *enc_md_pos
= strchr (P_pos
, '*');
16372 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16374 uint32_t P_len
= enc_md_pos
- P_pos
;
16378 char *id_len_pos
= strchr (enc_md_pos
, '*');
16380 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16382 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16386 char *id_buf_pos
= strchr (id_len_pos
, '*');
16388 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16394 char *u_len_pos
= strchr (id_buf_pos
, '*');
16396 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16398 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16400 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16404 char *u_buf_pos
= strchr (u_len_pos
, '*');
16406 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16408 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16412 char *o_len_pos
= strchr (u_buf_pos
, '*');
16414 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16416 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16418 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16422 char *o_buf_pos
= strchr (o_len_pos
, '*');
16424 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16426 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16430 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16432 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16434 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16436 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16440 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;
16442 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16446 const int V
= atoi (V_pos
);
16447 const int R
= atoi (R_pos
);
16448 const int P
= atoi (P_pos
);
16450 if (V
!= 1) return (PARSER_SALT_VALUE
);
16451 if (R
!= 2) return (PARSER_SALT_VALUE
);
16453 const int enc_md
= atoi (enc_md_pos
);
16455 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16457 const int id_len
= atoi (id_len_pos
);
16458 const int u_len
= atoi (u_len_pos
);
16459 const int o_len
= atoi (o_len_pos
);
16461 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16462 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16463 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16465 const int bits
= atoi (bits_pos
);
16467 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16469 // copy data to esalt
16475 pdf
->enc_md
= enc_md
;
16477 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16478 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16479 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16480 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16481 pdf
->id_len
= id_len
;
16483 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16484 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16485 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16486 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16487 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16488 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16489 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16490 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16491 pdf
->u_len
= u_len
;
16493 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16494 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16495 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16496 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16497 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16498 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16499 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16500 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16501 pdf
->o_len
= o_len
;
16503 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16504 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16505 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16506 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16508 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16509 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16510 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16511 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16512 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16513 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16514 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16515 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16517 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16518 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16519 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16520 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16521 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16522 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16523 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16524 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16526 pdf
->rc4key
[1] = 0;
16527 pdf
->rc4key
[0] = 0;
16529 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16530 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16531 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16532 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16533 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16534 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16535 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16536 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16537 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16538 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16540 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16541 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16543 // we use ID for salt, maybe needs to change, we will see...
16545 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16546 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16547 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16548 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16549 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16550 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16551 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16552 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16553 salt
->salt_len
= pdf
->id_len
+ 16;
16555 digest
[0] = pdf
->rc4key
[0];
16556 digest
[1] = pdf
->rc4key
[1];
16560 return (PARSER_OK
);
16563 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16565 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16567 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16569 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16571 salt_t
*salt
= hash_buf
->salt
;
16573 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16579 char *V_pos
= input_buf
+ 5;
16581 char *R_pos
= strchr (V_pos
, '*');
16583 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16585 uint32_t V_len
= R_pos
- V_pos
;
16589 char *bits_pos
= strchr (R_pos
, '*');
16591 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16593 uint32_t R_len
= bits_pos
- R_pos
;
16597 char *P_pos
= strchr (bits_pos
, '*');
16599 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16601 uint32_t bits_len
= P_pos
- bits_pos
;
16605 char *enc_md_pos
= strchr (P_pos
, '*');
16607 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16609 uint32_t P_len
= enc_md_pos
- P_pos
;
16613 char *id_len_pos
= strchr (enc_md_pos
, '*');
16615 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16617 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16621 char *id_buf_pos
= strchr (id_len_pos
, '*');
16623 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16625 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16629 char *u_len_pos
= strchr (id_buf_pos
, '*');
16631 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16633 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16635 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16639 char *u_buf_pos
= strchr (u_len_pos
, '*');
16641 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16643 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16647 char *o_len_pos
= strchr (u_buf_pos
, '*');
16649 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16651 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16653 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16657 char *o_buf_pos
= strchr (o_len_pos
, '*');
16659 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16661 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16665 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;
16667 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16671 const int V
= atoi (V_pos
);
16672 const int R
= atoi (R_pos
);
16673 const int P
= atoi (P_pos
);
16677 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16678 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16680 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16682 const int id_len
= atoi (id_len_pos
);
16683 const int u_len
= atoi (u_len_pos
);
16684 const int o_len
= atoi (o_len_pos
);
16686 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16688 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16689 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16691 const int bits
= atoi (bits_pos
);
16693 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16699 enc_md
= atoi (enc_md_pos
);
16702 // copy data to esalt
16708 pdf
->enc_md
= enc_md
;
16710 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16711 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16712 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16713 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16717 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16718 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16719 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16720 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16723 pdf
->id_len
= id_len
;
16725 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16726 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16727 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16728 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16729 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16730 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16731 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16732 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16733 pdf
->u_len
= u_len
;
16735 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16736 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16737 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16738 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16739 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16740 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16741 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16742 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16743 pdf
->o_len
= o_len
;
16745 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16746 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16747 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16748 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16752 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16753 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16754 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16755 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16758 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16759 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16760 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16761 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16762 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16763 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16764 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16765 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16767 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16768 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16769 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16770 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16771 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16772 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16773 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16774 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16776 // precompute rc4 data for later use
16792 uint salt_pc_block
[32];
16794 char *salt_pc_ptr
= (char *) salt_pc_block
;
16796 memcpy (salt_pc_ptr
, padding
, 32);
16797 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16799 uint salt_pc_digest
[4];
16801 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16803 pdf
->rc4data
[0] = salt_pc_digest
[0];
16804 pdf
->rc4data
[1] = salt_pc_digest
[1];
16806 // we use ID for salt, maybe needs to change, we will see...
16808 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16809 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16810 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16811 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16812 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16813 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16814 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16815 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16816 salt
->salt_len
= pdf
->id_len
+ 16;
16818 salt
->salt_iter
= ROUNDS_PDF14
;
16820 digest
[0] = pdf
->u_buf
[0];
16821 digest
[1] = pdf
->u_buf
[1];
16825 return (PARSER_OK
);
16828 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16830 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16832 if (ret
!= PARSER_OK
)
16837 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16839 salt_t
*salt
= hash_buf
->salt
;
16841 digest
[0] -= SHA256M_A
;
16842 digest
[1] -= SHA256M_B
;
16843 digest
[2] -= SHA256M_C
;
16844 digest
[3] -= SHA256M_D
;
16845 digest
[4] -= SHA256M_E
;
16846 digest
[5] -= SHA256M_F
;
16847 digest
[6] -= SHA256M_G
;
16848 digest
[7] -= SHA256M_H
;
16850 salt
->salt_buf
[2] = 0x80;
16852 return (PARSER_OK
);
16855 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16857 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16859 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16861 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16863 salt_t
*salt
= hash_buf
->salt
;
16865 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16871 char *V_pos
= input_buf
+ 5;
16873 char *R_pos
= strchr (V_pos
, '*');
16875 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16877 uint32_t V_len
= R_pos
- V_pos
;
16881 char *bits_pos
= strchr (R_pos
, '*');
16883 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16885 uint32_t R_len
= bits_pos
- R_pos
;
16889 char *P_pos
= strchr (bits_pos
, '*');
16891 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16893 uint32_t bits_len
= P_pos
- bits_pos
;
16897 char *enc_md_pos
= strchr (P_pos
, '*');
16899 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16901 uint32_t P_len
= enc_md_pos
- P_pos
;
16905 char *id_len_pos
= strchr (enc_md_pos
, '*');
16907 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16909 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16913 char *id_buf_pos
= strchr (id_len_pos
, '*');
16915 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16917 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16921 char *u_len_pos
= strchr (id_buf_pos
, '*');
16923 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16925 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16929 char *u_buf_pos
= strchr (u_len_pos
, '*');
16931 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16933 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16937 char *o_len_pos
= strchr (u_buf_pos
, '*');
16939 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16941 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16945 char *o_buf_pos
= strchr (o_len_pos
, '*');
16947 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16949 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16953 char *last
= strchr (o_buf_pos
, '*');
16955 if (last
== NULL
) last
= input_buf
+ input_len
;
16957 uint32_t o_buf_len
= last
- o_buf_pos
;
16961 const int V
= atoi (V_pos
);
16962 const int R
= atoi (R_pos
);
16966 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16967 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16969 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16971 const int bits
= atoi (bits_pos
);
16973 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16975 int enc_md
= atoi (enc_md_pos
);
16977 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16979 const uint id_len
= atoi (id_len_pos
);
16980 const uint u_len
= atoi (u_len_pos
);
16981 const uint o_len
= atoi (o_len_pos
);
16983 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16984 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16985 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16986 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16987 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16988 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16989 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16990 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16992 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16993 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16994 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16996 // copy data to esalt
16998 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17000 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17002 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
17005 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17006 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17008 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17009 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17011 salt
->salt_len
= 8;
17012 salt
->salt_iter
= ROUNDS_PDF17L8
;
17014 digest
[0] = pdf
->u_buf
[0];
17015 digest
[1] = pdf
->u_buf
[1];
17016 digest
[2] = pdf
->u_buf
[2];
17017 digest
[3] = pdf
->u_buf
[3];
17018 digest
[4] = pdf
->u_buf
[4];
17019 digest
[5] = pdf
->u_buf
[5];
17020 digest
[6] = pdf
->u_buf
[6];
17021 digest
[7] = pdf
->u_buf
[7];
17023 return (PARSER_OK
);
17026 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17028 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17030 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17032 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17034 salt_t
*salt
= hash_buf
->salt
;
17036 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17044 char *iter_pos
= input_buf
+ 7;
17046 uint32_t iter
= atoi (iter_pos
);
17048 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17049 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17051 // first is *raw* salt
17053 char *salt_pos
= strchr (iter_pos
, ':');
17055 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17059 char *hash_pos
= strchr (salt_pos
, ':');
17061 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17063 uint32_t salt_len
= hash_pos
- salt_pos
;
17065 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17069 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17071 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17075 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17077 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17079 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17081 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17082 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17084 salt
->salt_len
= salt_len
;
17085 salt
->salt_iter
= iter
- 1;
17091 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17093 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17095 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17097 memcpy (digest
, tmp_buf
, 16);
17099 digest
[0] = byte_swap_32 (digest
[0]);
17100 digest
[1] = byte_swap_32 (digest
[1]);
17101 digest
[2] = byte_swap_32 (digest
[2]);
17102 digest
[3] = byte_swap_32 (digest
[3]);
17104 // add some stuff to normal salt to make sorted happy
17106 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17107 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17108 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17109 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17110 salt
->salt_buf
[4] = salt
->salt_iter
;
17112 return (PARSER_OK
);
17115 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17117 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17119 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17121 salt_t
*salt
= hash_buf
->salt
;
17123 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17124 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17125 digest
[2] = hex_to_uint (&input_buf
[16]);
17126 digest
[3] = hex_to_uint (&input_buf
[24]);
17128 digest
[0] = byte_swap_32 (digest
[0]);
17129 digest
[1] = byte_swap_32 (digest
[1]);
17130 digest
[2] = byte_swap_32 (digest
[2]);
17131 digest
[3] = byte_swap_32 (digest
[3]);
17133 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17135 uint salt_len
= input_len
- 32 - 1;
17137 char *salt_buf
= input_buf
+ 32 + 1;
17139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17141 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17143 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17145 salt
->salt_len
= salt_len
;
17147 return (PARSER_OK
);
17150 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17152 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17154 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17156 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17158 salt_t
*salt
= hash_buf
->salt
;
17160 char *user_pos
= input_buf
+ 10;
17162 char *salt_pos
= strchr (user_pos
, '*');
17164 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17168 char *hash_pos
= strchr (salt_pos
, '*');
17172 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17174 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17176 uint user_len
= salt_pos
- user_pos
- 1;
17178 uint salt_len
= hash_pos
- salt_pos
- 1;
17180 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17186 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17187 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17188 digest
[2] = hex_to_uint (&hash_pos
[16]);
17189 digest
[3] = hex_to_uint (&hash_pos
[24]);
17191 digest
[0] = byte_swap_32 (digest
[0]);
17192 digest
[1] = byte_swap_32 (digest
[1]);
17193 digest
[2] = byte_swap_32 (digest
[2]);
17194 digest
[3] = byte_swap_32 (digest
[3]);
17196 digest
[0] -= MD5M_A
;
17197 digest
[1] -= MD5M_B
;
17198 digest
[2] -= MD5M_C
;
17199 digest
[3] -= MD5M_D
;
17205 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17207 // first 4 bytes are the "challenge"
17209 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17210 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17211 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17212 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17214 // append the user name
17216 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17218 salt
->salt_len
= 4 + user_len
;
17220 return (PARSER_OK
);
17223 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17225 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17227 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17229 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17231 salt_t
*salt
= hash_buf
->salt
;
17233 char *salt_pos
= input_buf
+ 9;
17235 char *hash_pos
= strchr (salt_pos
, '*');
17237 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17241 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17243 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17245 uint salt_len
= hash_pos
- salt_pos
- 1;
17247 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17253 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17254 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17255 digest
[2] = hex_to_uint (&hash_pos
[16]);
17256 digest
[3] = hex_to_uint (&hash_pos
[24]);
17257 digest
[4] = hex_to_uint (&hash_pos
[32]);
17263 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17265 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17267 salt
->salt_len
= salt_len
;
17269 return (PARSER_OK
);
17272 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17274 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17276 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17278 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17280 salt_t
*salt
= hash_buf
->salt
;
17282 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17288 char *cry_master_len_pos
= input_buf
+ 9;
17290 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17292 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17294 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17296 cry_master_buf_pos
++;
17298 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17300 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17304 cry_salt_len_pos
++;
17306 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17308 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17310 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17312 cry_salt_buf_pos
++;
17314 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17316 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17318 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17322 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17324 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17326 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17330 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17332 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17334 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17338 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17340 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17342 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17344 public_key_len_pos
++;
17346 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17348 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17350 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17352 public_key_buf_pos
++;
17354 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;
17356 const uint cry_master_len
= atoi (cry_master_len_pos
);
17357 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17358 const uint ckey_len
= atoi (ckey_len_pos
);
17359 const uint public_key_len
= atoi (public_key_len_pos
);
17361 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17362 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17363 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17364 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17366 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17368 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17370 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17373 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17375 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17377 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17380 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17382 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17384 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17387 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17388 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17389 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17392 * store digest (should be unique enought, hopefully)
17395 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17396 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17397 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17398 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17404 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17406 const uint cry_rounds
= atoi (cry_rounds_pos
);
17408 salt
->salt_iter
= cry_rounds
- 1;
17410 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17412 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17414 salt
->salt_len
= salt_len
;
17416 return (PARSER_OK
);
17419 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17421 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17423 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17425 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17427 salt_t
*salt
= hash_buf
->salt
;
17429 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17431 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17433 char temp_input_buf
[input_len
+ 1];
17435 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17436 memcpy (temp_input_buf
, input_buf
, input_len
);
17440 char *URI_server_pos
= temp_input_buf
+ 6;
17442 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17444 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17446 URI_client_pos
[0] = 0;
17449 uint URI_server_len
= strlen (URI_server_pos
);
17451 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17455 char *user_pos
= strchr (URI_client_pos
, '*');
17457 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17462 uint URI_client_len
= strlen (URI_client_pos
);
17464 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17468 char *realm_pos
= strchr (user_pos
, '*');
17470 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17475 uint user_len
= strlen (user_pos
);
17477 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17481 char *method_pos
= strchr (realm_pos
, '*');
17483 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17488 uint realm_len
= strlen (realm_pos
);
17490 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17494 char *URI_prefix_pos
= strchr (method_pos
, '*');
17496 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17498 URI_prefix_pos
[0] = 0;
17501 uint method_len
= strlen (method_pos
);
17503 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17507 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17509 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17511 URI_resource_pos
[0] = 0;
17512 URI_resource_pos
++;
17514 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17516 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17520 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17522 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17524 URI_suffix_pos
[0] = 0;
17527 uint URI_resource_len
= strlen (URI_resource_pos
);
17529 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17530 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17534 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17536 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17541 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17543 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17547 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17549 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17551 nonce_client_pos
[0] = 0;
17552 nonce_client_pos
++;
17554 uint nonce_len
= strlen (nonce_pos
);
17556 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17557 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17561 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17563 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17565 nonce_count_pos
[0] = 0;
17568 uint nonce_client_len
= strlen (nonce_client_pos
);
17570 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17574 char *qop_pos
= strchr (nonce_count_pos
, '*');
17576 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17581 uint nonce_count_len
= strlen (nonce_count_pos
);
17583 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17587 char *directive_pos
= strchr (qop_pos
, '*');
17589 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17591 directive_pos
[0] = 0;
17594 uint qop_len
= strlen (qop_pos
);
17596 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17600 char *digest_pos
= strchr (directive_pos
, '*');
17602 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17607 uint directive_len
= strlen (directive_pos
);
17609 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17611 if (memcmp (directive_pos
, "MD5", 3))
17613 log_info ("ERROR: only the MD5 directive is currently supported\n");
17615 return (PARSER_SIP_AUTH_DIRECTIVE
);
17619 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17624 uint md5_max_len
= 4 * 64;
17626 uint md5_remaining_len
= md5_max_len
;
17628 uint tmp_md5_buf
[md5_max_len
/ 4];
17630 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17632 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17634 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17636 md5_len
+= method_len
+ 1;
17637 tmp_md5_ptr
+= method_len
+ 1;
17639 if (URI_prefix_len
> 0)
17641 md5_remaining_len
= md5_max_len
- md5_len
;
17643 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17645 md5_len
+= URI_prefix_len
+ 1;
17646 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17649 md5_remaining_len
= md5_max_len
- md5_len
;
17651 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17653 md5_len
+= URI_resource_len
;
17654 tmp_md5_ptr
+= URI_resource_len
;
17656 if (URI_suffix_len
> 0)
17658 md5_remaining_len
= md5_max_len
- md5_len
;
17660 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17662 md5_len
+= 1 + URI_suffix_len
;
17665 uint tmp_digest
[4];
17667 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17669 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17670 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17671 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17672 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17678 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17680 uint esalt_len
= 0;
17682 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17684 // there are 2 possibilities for the esalt:
17686 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17688 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17690 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17692 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17704 esalt_len
= 1 + nonce_len
+ 1 + 32;
17706 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17708 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17716 // add 0x80 to esalt
17718 esalt_buf_ptr
[esalt_len
] = 0x80;
17720 sip
->esalt_len
= esalt_len
;
17726 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17728 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17730 uint max_salt_len
= 119;
17732 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17734 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17736 sip
->salt_len
= salt_len
;
17739 * fake salt (for sorting)
17742 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17746 uint fake_salt_len
= salt_len
;
17748 if (fake_salt_len
> max_salt_len
)
17750 fake_salt_len
= max_salt_len
;
17753 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17755 salt
->salt_len
= fake_salt_len
;
17761 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17762 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17763 digest
[2] = hex_to_uint (&digest_pos
[16]);
17764 digest
[3] = hex_to_uint (&digest_pos
[24]);
17766 digest
[0] = byte_swap_32 (digest
[0]);
17767 digest
[1] = byte_swap_32 (digest
[1]);
17768 digest
[2] = byte_swap_32 (digest
[2]);
17769 digest
[3] = byte_swap_32 (digest
[3]);
17771 return (PARSER_OK
);
17774 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17776 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17778 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17780 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17782 salt_t
*salt
= hash_buf
->salt
;
17786 char *digest_pos
= input_buf
;
17788 digest
[0] = hex_to_uint (&digest_pos
[0]);
17795 char *salt_buf
= input_buf
+ 8 + 1;
17799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17801 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17803 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17805 salt
->salt_len
= salt_len
;
17807 return (PARSER_OK
);
17810 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17812 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17814 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17816 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17818 salt_t
*salt
= hash_buf
->salt
;
17820 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17826 char *p_buf_pos
= input_buf
+ 4;
17828 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17830 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17832 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17834 NumCyclesPower_pos
++;
17836 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17838 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17840 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17844 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17846 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17848 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17852 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17854 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17856 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17860 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17862 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17864 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17868 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17870 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17872 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17876 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17878 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17880 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17884 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17886 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17888 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17892 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17894 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17896 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17900 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;
17902 const uint iter
= atoi (NumCyclesPower_pos
);
17903 const uint crc
= atoi (crc_buf_pos
);
17904 const uint p_buf
= atoi (p_buf_pos
);
17905 const uint salt_len
= atoi (salt_len_pos
);
17906 const uint iv_len
= atoi (iv_len_pos
);
17907 const uint unpack_size
= atoi (unpack_size_pos
);
17908 const uint data_len
= atoi (data_len_pos
);
17914 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17915 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17917 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17919 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17921 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17927 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17928 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17929 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17930 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17932 seven_zip
->iv_len
= iv_len
;
17934 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17936 seven_zip
->salt_len
= 0;
17938 seven_zip
->crc
= crc
;
17940 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17942 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17944 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17947 seven_zip
->data_len
= data_len
;
17949 seven_zip
->unpack_size
= unpack_size
;
17953 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17954 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17955 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17956 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17958 salt
->salt_len
= 16;
17960 salt
->salt_sign
[0] = iter
;
17962 salt
->salt_iter
= 1 << iter
;
17973 return (PARSER_OK
);
17976 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17978 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17980 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17982 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17983 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17984 digest
[2] = hex_to_uint (&input_buf
[16]);
17985 digest
[3] = hex_to_uint (&input_buf
[24]);
17986 digest
[4] = hex_to_uint (&input_buf
[32]);
17987 digest
[5] = hex_to_uint (&input_buf
[40]);
17988 digest
[6] = hex_to_uint (&input_buf
[48]);
17989 digest
[7] = hex_to_uint (&input_buf
[56]);
17991 digest
[0] = byte_swap_32 (digest
[0]);
17992 digest
[1] = byte_swap_32 (digest
[1]);
17993 digest
[2] = byte_swap_32 (digest
[2]);
17994 digest
[3] = byte_swap_32 (digest
[3]);
17995 digest
[4] = byte_swap_32 (digest
[4]);
17996 digest
[5] = byte_swap_32 (digest
[5]);
17997 digest
[6] = byte_swap_32 (digest
[6]);
17998 digest
[7] = byte_swap_32 (digest
[7]);
18000 return (PARSER_OK
);
18003 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18005 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18007 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18009 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
18010 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
18011 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
18012 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
18013 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
18014 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
18015 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
18016 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
18017 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
18018 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
18019 digest
[10] = hex_to_uint (&input_buf
[ 80]);
18020 digest
[11] = hex_to_uint (&input_buf
[ 88]);
18021 digest
[12] = hex_to_uint (&input_buf
[ 96]);
18022 digest
[13] = hex_to_uint (&input_buf
[104]);
18023 digest
[14] = hex_to_uint (&input_buf
[112]);
18024 digest
[15] = hex_to_uint (&input_buf
[120]);
18026 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18027 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18028 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18029 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18030 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18031 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18032 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18033 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18034 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18035 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18036 digest
[10] = byte_swap_32 (digest
[10]);
18037 digest
[11] = byte_swap_32 (digest
[11]);
18038 digest
[12] = byte_swap_32 (digest
[12]);
18039 digest
[13] = byte_swap_32 (digest
[13]);
18040 digest
[14] = byte_swap_32 (digest
[14]);
18041 digest
[15] = byte_swap_32 (digest
[15]);
18043 return (PARSER_OK
);
18046 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18048 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18050 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18052 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18054 salt_t
*salt
= hash_buf
->salt
;
18056 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18064 char *iter_pos
= input_buf
+ 4;
18066 uint32_t iter
= atoi (iter_pos
);
18068 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18069 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18071 // first is *raw* salt
18073 char *salt_pos
= strchr (iter_pos
, ':');
18075 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18079 char *hash_pos
= strchr (salt_pos
, ':');
18081 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18083 uint32_t salt_len
= hash_pos
- salt_pos
;
18085 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18089 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18091 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18095 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18097 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18099 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18101 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18102 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18104 salt
->salt_len
= salt_len
;
18105 salt
->salt_iter
= iter
- 1;
18111 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18113 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18115 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18117 memcpy (digest
, tmp_buf
, 16);
18119 // add some stuff to normal salt to make sorted happy
18121 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18122 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18123 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18124 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18125 salt
->salt_buf
[4] = salt
->salt_iter
;
18127 return (PARSER_OK
);
18130 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18132 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18134 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18136 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18138 salt_t
*salt
= hash_buf
->salt
;
18140 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18148 char *iter_pos
= input_buf
+ 5;
18150 uint32_t iter
= atoi (iter_pos
);
18152 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18153 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18155 // first is *raw* salt
18157 char *salt_pos
= strchr (iter_pos
, ':');
18159 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18163 char *hash_pos
= strchr (salt_pos
, ':');
18165 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18167 uint32_t salt_len
= hash_pos
- salt_pos
;
18169 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18173 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18175 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18179 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18185 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18186 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18188 salt
->salt_len
= salt_len
;
18189 salt
->salt_iter
= iter
- 1;
18195 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18197 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18199 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18201 memcpy (digest
, tmp_buf
, 16);
18203 digest
[0] = byte_swap_32 (digest
[0]);
18204 digest
[1] = byte_swap_32 (digest
[1]);
18205 digest
[2] = byte_swap_32 (digest
[2]);
18206 digest
[3] = byte_swap_32 (digest
[3]);
18208 // add some stuff to normal salt to make sorted happy
18210 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18211 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18212 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18213 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18214 salt
->salt_buf
[4] = salt
->salt_iter
;
18216 return (PARSER_OK
);
18219 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18221 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18223 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18225 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18227 salt_t
*salt
= hash_buf
->salt
;
18229 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18237 char *iter_pos
= input_buf
+ 7;
18239 uint32_t iter
= atoi (iter_pos
);
18241 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18242 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18244 // first is *raw* salt
18246 char *salt_pos
= strchr (iter_pos
, ':');
18248 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18252 char *hash_pos
= strchr (salt_pos
, ':');
18254 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18256 uint32_t salt_len
= hash_pos
- salt_pos
;
18258 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18262 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18264 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18268 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18274 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18275 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18277 salt
->salt_len
= salt_len
;
18278 salt
->salt_iter
= iter
- 1;
18284 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18286 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18288 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18290 memcpy (digest
, tmp_buf
, 64);
18292 digest
[0] = byte_swap_64 (digest
[0]);
18293 digest
[1] = byte_swap_64 (digest
[1]);
18294 digest
[2] = byte_swap_64 (digest
[2]);
18295 digest
[3] = byte_swap_64 (digest
[3]);
18296 digest
[4] = byte_swap_64 (digest
[4]);
18297 digest
[5] = byte_swap_64 (digest
[5]);
18298 digest
[6] = byte_swap_64 (digest
[6]);
18299 digest
[7] = byte_swap_64 (digest
[7]);
18301 // add some stuff to normal salt to make sorted happy
18303 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18304 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18305 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18306 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18307 salt
->salt_buf
[4] = salt
->salt_iter
;
18309 return (PARSER_OK
);
18312 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18314 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18316 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18318 uint
*digest
= (uint
*) hash_buf
->digest
;
18320 salt_t
*salt
= hash_buf
->salt
;
18326 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18328 char *hash_pos
= strchr (salt_pos
, '$');
18330 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18332 uint32_t salt_len
= hash_pos
- salt_pos
;
18334 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18338 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18340 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18344 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18345 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18363 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18364 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18366 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18367 salt
->salt_len
= 8;
18369 return (PARSER_OK
);
18372 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18374 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18376 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18378 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18380 if (c19
& 3) return (PARSER_HASH_VALUE
);
18382 salt_t
*salt
= hash_buf
->salt
;
18384 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18388 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18389 | itoa64_to_int (input_buf
[2]) << 6
18390 | itoa64_to_int (input_buf
[3]) << 12
18391 | itoa64_to_int (input_buf
[4]) << 18;
18395 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18396 | itoa64_to_int (input_buf
[6]) << 6
18397 | itoa64_to_int (input_buf
[7]) << 12
18398 | itoa64_to_int (input_buf
[8]) << 18;
18400 salt
->salt_len
= 4;
18404 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18406 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18408 memcpy (digest
, tmp_buf
, 8);
18412 IP (digest
[0], digest
[1], tt
);
18414 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18415 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18419 return (PARSER_OK
);
18422 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18424 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18426 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18428 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18430 salt_t
*salt
= hash_buf
->salt
;
18436 char *type_pos
= input_buf
+ 6 + 1;
18438 char *salt_pos
= strchr (type_pos
, '*');
18440 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18442 uint32_t type_len
= salt_pos
- type_pos
;
18444 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18448 char *crypted_pos
= strchr (salt_pos
, '*');
18450 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18452 uint32_t salt_len
= crypted_pos
- salt_pos
;
18454 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18458 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18460 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18466 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18467 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18469 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18470 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18472 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18473 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18474 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18475 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18477 salt
->salt_len
= 24;
18478 salt
->salt_iter
= ROUNDS_RAR3
;
18480 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18481 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18483 digest
[0] = 0xc43d7b00;
18484 digest
[1] = 0x40070000;
18488 return (PARSER_OK
);
18491 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18493 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18495 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18497 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18499 salt_t
*salt
= hash_buf
->salt
;
18501 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18507 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18509 char *param1_pos
= strchr (param0_pos
, '$');
18511 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18513 uint32_t param0_len
= param1_pos
- param0_pos
;
18517 char *param2_pos
= strchr (param1_pos
, '$');
18519 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18521 uint32_t param1_len
= param2_pos
- param1_pos
;
18525 char *param3_pos
= strchr (param2_pos
, '$');
18527 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18529 uint32_t param2_len
= param3_pos
- param2_pos
;
18533 char *param4_pos
= strchr (param3_pos
, '$');
18535 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18537 uint32_t param3_len
= param4_pos
- param3_pos
;
18541 char *param5_pos
= strchr (param4_pos
, '$');
18543 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18545 uint32_t param4_len
= param5_pos
- param4_pos
;
18549 uint32_t param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18551 char *salt_buf
= param1_pos
;
18552 char *iv
= param3_pos
;
18553 char *pswcheck
= param5_pos
;
18555 const uint salt_len
= atoi (param0_pos
);
18556 const uint iterations
= atoi (param2_pos
);
18557 const uint pswcheck_len
= atoi (param4_pos
);
18563 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18564 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18565 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18567 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18568 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18569 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18575 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
18576 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
18577 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
18578 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
18580 rar5
->iv
[0] = hex_to_uint (&iv
[ 0]);
18581 rar5
->iv
[1] = hex_to_uint (&iv
[ 8]);
18582 rar5
->iv
[2] = hex_to_uint (&iv
[16]);
18583 rar5
->iv
[3] = hex_to_uint (&iv
[24]);
18585 salt
->salt_len
= 16;
18587 salt
->salt_sign
[0] = iterations
;
18589 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18595 digest
[0] = hex_to_uint (&pswcheck
[ 0]);
18596 digest
[1] = hex_to_uint (&pswcheck
[ 8]);
18600 return (PARSER_OK
);
18603 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18605 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18607 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18609 salt_t
*salt
= hash_buf
->salt
;
18611 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18612 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18613 digest
[2] = hex_to_uint (&input_buf
[16]);
18614 digest
[3] = hex_to_uint (&input_buf
[24]);
18615 digest
[4] = hex_to_uint (&input_buf
[32]);
18616 digest
[5] = hex_to_uint (&input_buf
[40]);
18617 digest
[6] = hex_to_uint (&input_buf
[48]);
18618 digest
[7] = hex_to_uint (&input_buf
[56]);
18620 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18622 uint salt_len
= input_len
- 64 - 1;
18624 char *salt_buf
= input_buf
+ 64 + 1;
18626 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18628 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18630 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18632 salt
->salt_len
= salt_len
;
18635 * we can precompute the first sha256 transform
18640 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18641 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18642 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18643 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18644 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18645 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18646 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18647 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18648 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18649 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18650 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18651 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18652 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18653 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18654 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18655 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18659 pc256
[0] = SHA256M_A
;
18660 pc256
[1] = SHA256M_B
;
18661 pc256
[2] = SHA256M_C
;
18662 pc256
[3] = SHA256M_D
;
18663 pc256
[4] = SHA256M_E
;
18664 pc256
[5] = SHA256M_F
;
18665 pc256
[6] = SHA256M_G
;
18666 pc256
[7] = SHA256M_H
;
18668 sha256_64 (w
, pc256
);
18670 salt
->salt_buf_pc
[0] = pc256
[0];
18671 salt
->salt_buf_pc
[1] = pc256
[1];
18672 salt
->salt_buf_pc
[2] = pc256
[2];
18673 salt
->salt_buf_pc
[3] = pc256
[3];
18674 salt
->salt_buf_pc
[4] = pc256
[4];
18675 salt
->salt_buf_pc
[5] = pc256
[5];
18676 salt
->salt_buf_pc
[6] = pc256
[6];
18677 salt
->salt_buf_pc
[7] = pc256
[7];
18679 digest
[0] -= pc256
[0];
18680 digest
[1] -= pc256
[1];
18681 digest
[2] -= pc256
[2];
18682 digest
[3] -= pc256
[3];
18683 digest
[4] -= pc256
[4];
18684 digest
[5] -= pc256
[5];
18685 digest
[6] -= pc256
[6];
18686 digest
[7] -= pc256
[7];
18688 return (PARSER_OK
);
18691 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18693 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18695 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18697 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18699 salt_t
*salt
= hash_buf
->salt
;
18705 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18707 char *data_buf_pos
= strchr (data_len_pos
, '$');
18709 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18711 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18713 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18714 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18718 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18720 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18722 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18724 uint32_t data_len
= atoi (data_len_pos
);
18726 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18732 char *salt_pos
= data_buf_pos
;
18734 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18735 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18736 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18737 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18739 // this is actually the CT, which is also the hash later (if matched)
18741 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18742 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18743 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18744 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18746 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18748 salt
->salt_iter
= 10 - 1;
18754 digest
[0] = salt
->salt_buf
[4];
18755 digest
[1] = salt
->salt_buf
[5];
18756 digest
[2] = salt
->salt_buf
[6];
18757 digest
[3] = salt
->salt_buf
[7];
18759 return (PARSER_OK
);
18762 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18764 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18766 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18768 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18770 salt_t
*salt
= hash_buf
->salt
;
18776 char *salt_pos
= input_buf
+ 11 + 1;
18778 char *iter_pos
= strchr (salt_pos
, ',');
18780 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18782 uint32_t salt_len
= iter_pos
- salt_pos
;
18784 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18788 char *hash_pos
= strchr (iter_pos
, ',');
18790 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18792 uint32_t iter_len
= hash_pos
- iter_pos
;
18794 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18798 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18800 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18806 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18807 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18808 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18809 salt
->salt_buf
[3] = 0x00018000;
18811 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18812 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18813 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18814 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18816 salt
->salt_len
= salt_len
/ 2;
18818 salt
->salt_iter
= atoi (iter_pos
) - 1;
18824 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18825 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18826 digest
[2] = hex_to_uint (&hash_pos
[16]);
18827 digest
[3] = hex_to_uint (&hash_pos
[24]);
18828 digest
[4] = hex_to_uint (&hash_pos
[32]);
18829 digest
[5] = hex_to_uint (&hash_pos
[40]);
18830 digest
[6] = hex_to_uint (&hash_pos
[48]);
18831 digest
[7] = hex_to_uint (&hash_pos
[56]);
18833 return (PARSER_OK
);
18836 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18838 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18840 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18842 salt_t
*salt
= hash_buf
->salt
;
18848 char *hash_pos
= input_buf
+ 64;
18849 char *salt1_pos
= input_buf
+ 128;
18850 char *salt2_pos
= input_buf
;
18856 salt
->salt_buf
[ 0] = hex_to_uint (&salt1_pos
[ 0]);
18857 salt
->salt_buf
[ 1] = hex_to_uint (&salt1_pos
[ 8]);
18858 salt
->salt_buf
[ 2] = hex_to_uint (&salt1_pos
[16]);
18859 salt
->salt_buf
[ 3] = hex_to_uint (&salt1_pos
[24]);
18861 salt
->salt_buf
[ 4] = hex_to_uint (&salt2_pos
[ 0]);
18862 salt
->salt_buf
[ 5] = hex_to_uint (&salt2_pos
[ 8]);
18863 salt
->salt_buf
[ 6] = hex_to_uint (&salt2_pos
[16]);
18864 salt
->salt_buf
[ 7] = hex_to_uint (&salt2_pos
[24]);
18866 salt
->salt_buf
[ 8] = hex_to_uint (&salt2_pos
[32]);
18867 salt
->salt_buf
[ 9] = hex_to_uint (&salt2_pos
[40]);
18868 salt
->salt_buf
[10] = hex_to_uint (&salt2_pos
[48]);
18869 salt
->salt_buf
[11] = hex_to_uint (&salt2_pos
[56]);
18871 salt
->salt_len
= 48;
18873 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18879 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18880 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18881 digest
[2] = hex_to_uint (&hash_pos
[16]);
18882 digest
[3] = hex_to_uint (&hash_pos
[24]);
18883 digest
[4] = hex_to_uint (&hash_pos
[32]);
18884 digest
[5] = hex_to_uint (&hash_pos
[40]);
18885 digest
[6] = hex_to_uint (&hash_pos
[48]);
18886 digest
[7] = hex_to_uint (&hash_pos
[56]);
18888 return (PARSER_OK
);
18892 * parallel running threads
18897 BOOL WINAPI
sigHandler_default (DWORD sig
)
18901 case CTRL_CLOSE_EVENT
:
18904 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18905 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18906 * function otherwise it is to late (e.g. after returning from this function)
18911 SetConsoleCtrlHandler (NULL
, TRUE
);
18918 case CTRL_LOGOFF_EVENT
:
18919 case CTRL_SHUTDOWN_EVENT
:
18923 SetConsoleCtrlHandler (NULL
, TRUE
);
18931 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18935 case CTRL_CLOSE_EVENT
:
18939 SetConsoleCtrlHandler (NULL
, TRUE
);
18946 case CTRL_LOGOFF_EVENT
:
18947 case CTRL_SHUTDOWN_EVENT
:
18951 SetConsoleCtrlHandler (NULL
, TRUE
);
18959 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18961 if (callback
== NULL
)
18963 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18967 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18973 void sigHandler_default (int sig
)
18977 signal (sig
, NULL
);
18980 void sigHandler_benchmark (int sig
)
18984 signal (sig
, NULL
);
18987 void hc_signal (void (callback
) (int))
18989 if (callback
== NULL
) callback
= SIG_DFL
;
18991 signal (SIGINT
, callback
);
18992 signal (SIGTERM
, callback
);
18993 signal (SIGABRT
, callback
);
18998 void status_display ();
19000 void *thread_keypress (void *p
)
19002 int benchmark
= *((int *) p
);
19004 uint quiet
= data
.quiet
;
19008 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19010 int ch
= tty_getchar();
19012 if (ch
== -1) break;
19014 if (ch
== 0) continue;
19020 hc_thread_mutex_lock (mux_display
);
19035 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19036 if (quiet
== 0) fflush (stdout
);
19048 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19049 if (quiet
== 0) fflush (stdout
);
19061 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19062 if (quiet
== 0) fflush (stdout
);
19074 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19075 if (quiet
== 0) fflush (stdout
);
19083 if (benchmark
== 1) break;
19085 stop_at_checkpoint ();
19089 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19090 if (quiet
== 0) fflush (stdout
);
19098 if (benchmark
== 1)
19110 hc_thread_mutex_unlock (mux_display
);
19122 bool class_num (char c
)
19124 return ((c
>= '0') && (c
<= '9'));
19127 bool class_lower (char c
)
19129 return ((c
>= 'a') && (c
<= 'z'));
19132 bool class_upper (char c
)
19134 return ((c
>= 'A') && (c
<= 'Z'));
19137 bool class_alpha (char c
)
19139 return (class_lower (c
) || class_upper (c
));
19142 char conv_ctoi (char c
)
19148 else if (class_upper (c
))
19150 return c
- 'A' + (char) 10;
19153 return (char) (-1);
19156 char conv_itoc (char c
)
19164 return c
+ 'A' - (char) 10;
19167 return (char) (-1);
19174 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19175 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19176 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19177 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19178 #define MAX_KERNEL_RULES 255
19179 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19180 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19181 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19183 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19184 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19185 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19186 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19188 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19193 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19195 switch (rule_buf
[rule_pos
])
19201 case RULE_OP_MANGLE_NOOP
:
19202 SET_NAME (rule
, rule_buf
[rule_pos
]);
19205 case RULE_OP_MANGLE_LREST
:
19206 SET_NAME (rule
, rule_buf
[rule_pos
]);
19209 case RULE_OP_MANGLE_UREST
:
19210 SET_NAME (rule
, rule_buf
[rule_pos
]);
19213 case RULE_OP_MANGLE_LREST_UFIRST
:
19214 SET_NAME (rule
, rule_buf
[rule_pos
]);
19217 case RULE_OP_MANGLE_UREST_LFIRST
:
19218 SET_NAME (rule
, rule_buf
[rule_pos
]);
19221 case RULE_OP_MANGLE_TREST
:
19222 SET_NAME (rule
, rule_buf
[rule_pos
]);
19225 case RULE_OP_MANGLE_TOGGLE_AT
:
19226 SET_NAME (rule
, rule_buf
[rule_pos
]);
19227 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19230 case RULE_OP_MANGLE_REVERSE
:
19231 SET_NAME (rule
, rule_buf
[rule_pos
]);
19234 case RULE_OP_MANGLE_DUPEWORD
:
19235 SET_NAME (rule
, rule_buf
[rule_pos
]);
19238 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19239 SET_NAME (rule
, rule_buf
[rule_pos
]);
19240 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19243 case RULE_OP_MANGLE_REFLECT
:
19244 SET_NAME (rule
, rule_buf
[rule_pos
]);
19247 case RULE_OP_MANGLE_ROTATE_LEFT
:
19248 SET_NAME (rule
, rule_buf
[rule_pos
]);
19251 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19252 SET_NAME (rule
, rule_buf
[rule_pos
]);
19255 case RULE_OP_MANGLE_APPEND
:
19256 SET_NAME (rule
, rule_buf
[rule_pos
]);
19257 SET_P0 (rule
, rule_buf
[rule_pos
]);
19260 case RULE_OP_MANGLE_PREPEND
:
19261 SET_NAME (rule
, rule_buf
[rule_pos
]);
19262 SET_P0 (rule
, rule_buf
[rule_pos
]);
19265 case RULE_OP_MANGLE_DELETE_FIRST
:
19266 SET_NAME (rule
, rule_buf
[rule_pos
]);
19269 case RULE_OP_MANGLE_DELETE_LAST
:
19270 SET_NAME (rule
, rule_buf
[rule_pos
]);
19273 case RULE_OP_MANGLE_DELETE_AT
:
19274 SET_NAME (rule
, rule_buf
[rule_pos
]);
19275 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19278 case RULE_OP_MANGLE_EXTRACT
:
19279 SET_NAME (rule
, rule_buf
[rule_pos
]);
19280 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19281 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19284 case RULE_OP_MANGLE_OMIT
:
19285 SET_NAME (rule
, rule_buf
[rule_pos
]);
19286 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19287 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19290 case RULE_OP_MANGLE_INSERT
:
19291 SET_NAME (rule
, rule_buf
[rule_pos
]);
19292 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19293 SET_P1 (rule
, rule_buf
[rule_pos
]);
19296 case RULE_OP_MANGLE_OVERSTRIKE
:
19297 SET_NAME (rule
, rule_buf
[rule_pos
]);
19298 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19299 SET_P1 (rule
, rule_buf
[rule_pos
]);
19302 case RULE_OP_MANGLE_TRUNCATE_AT
:
19303 SET_NAME (rule
, rule_buf
[rule_pos
]);
19304 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19307 case RULE_OP_MANGLE_REPLACE
:
19308 SET_NAME (rule
, rule_buf
[rule_pos
]);
19309 SET_P0 (rule
, rule_buf
[rule_pos
]);
19310 SET_P1 (rule
, rule_buf
[rule_pos
]);
19313 case RULE_OP_MANGLE_PURGECHAR
:
19317 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19321 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19322 SET_NAME (rule
, rule_buf
[rule_pos
]);
19323 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19326 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19327 SET_NAME (rule
, rule_buf
[rule_pos
]);
19328 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19331 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19332 SET_NAME (rule
, rule_buf
[rule_pos
]);
19335 case RULE_OP_MANGLE_SWITCH_FIRST
:
19336 SET_NAME (rule
, rule_buf
[rule_pos
]);
19339 case RULE_OP_MANGLE_SWITCH_LAST
:
19340 SET_NAME (rule
, rule_buf
[rule_pos
]);
19343 case RULE_OP_MANGLE_SWITCH_AT
:
19344 SET_NAME (rule
, rule_buf
[rule_pos
]);
19345 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19346 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19349 case RULE_OP_MANGLE_CHR_SHIFTL
:
19350 SET_NAME (rule
, rule_buf
[rule_pos
]);
19351 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19354 case RULE_OP_MANGLE_CHR_SHIFTR
:
19355 SET_NAME (rule
, rule_buf
[rule_pos
]);
19356 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19359 case RULE_OP_MANGLE_CHR_INCR
:
19360 SET_NAME (rule
, rule_buf
[rule_pos
]);
19361 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19364 case RULE_OP_MANGLE_CHR_DECR
:
19365 SET_NAME (rule
, rule_buf
[rule_pos
]);
19366 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19369 case RULE_OP_MANGLE_REPLACE_NP1
:
19370 SET_NAME (rule
, rule_buf
[rule_pos
]);
19371 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19374 case RULE_OP_MANGLE_REPLACE_NM1
:
19375 SET_NAME (rule
, rule_buf
[rule_pos
]);
19376 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19379 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19380 SET_NAME (rule
, rule_buf
[rule_pos
]);
19381 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19384 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19385 SET_NAME (rule
, rule_buf
[rule_pos
]);
19386 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19389 case RULE_OP_MANGLE_TITLE
:
19390 SET_NAME (rule
, rule_buf
[rule_pos
]);
19399 if (rule_pos
< rule_len
) return (-1);
19404 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19408 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19412 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19416 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19420 case RULE_OP_MANGLE_NOOP
:
19421 rule_buf
[rule_pos
] = rule_cmd
;
19424 case RULE_OP_MANGLE_LREST
:
19425 rule_buf
[rule_pos
] = rule_cmd
;
19428 case RULE_OP_MANGLE_UREST
:
19429 rule_buf
[rule_pos
] = rule_cmd
;
19432 case RULE_OP_MANGLE_LREST_UFIRST
:
19433 rule_buf
[rule_pos
] = rule_cmd
;
19436 case RULE_OP_MANGLE_UREST_LFIRST
:
19437 rule_buf
[rule_pos
] = rule_cmd
;
19440 case RULE_OP_MANGLE_TREST
:
19441 rule_buf
[rule_pos
] = rule_cmd
;
19444 case RULE_OP_MANGLE_TOGGLE_AT
:
19445 rule_buf
[rule_pos
] = rule_cmd
;
19446 GET_P0_CONV (rule
);
19449 case RULE_OP_MANGLE_REVERSE
:
19450 rule_buf
[rule_pos
] = rule_cmd
;
19453 case RULE_OP_MANGLE_DUPEWORD
:
19454 rule_buf
[rule_pos
] = rule_cmd
;
19457 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19458 rule_buf
[rule_pos
] = rule_cmd
;
19459 GET_P0_CONV (rule
);
19462 case RULE_OP_MANGLE_REFLECT
:
19463 rule_buf
[rule_pos
] = rule_cmd
;
19466 case RULE_OP_MANGLE_ROTATE_LEFT
:
19467 rule_buf
[rule_pos
] = rule_cmd
;
19470 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19471 rule_buf
[rule_pos
] = rule_cmd
;
19474 case RULE_OP_MANGLE_APPEND
:
19475 rule_buf
[rule_pos
] = rule_cmd
;
19479 case RULE_OP_MANGLE_PREPEND
:
19480 rule_buf
[rule_pos
] = rule_cmd
;
19484 case RULE_OP_MANGLE_DELETE_FIRST
:
19485 rule_buf
[rule_pos
] = rule_cmd
;
19488 case RULE_OP_MANGLE_DELETE_LAST
:
19489 rule_buf
[rule_pos
] = rule_cmd
;
19492 case RULE_OP_MANGLE_DELETE_AT
:
19493 rule_buf
[rule_pos
] = rule_cmd
;
19494 GET_P0_CONV (rule
);
19497 case RULE_OP_MANGLE_EXTRACT
:
19498 rule_buf
[rule_pos
] = rule_cmd
;
19499 GET_P0_CONV (rule
);
19500 GET_P1_CONV (rule
);
19503 case RULE_OP_MANGLE_OMIT
:
19504 rule_buf
[rule_pos
] = rule_cmd
;
19505 GET_P0_CONV (rule
);
19506 GET_P1_CONV (rule
);
19509 case RULE_OP_MANGLE_INSERT
:
19510 rule_buf
[rule_pos
] = rule_cmd
;
19511 GET_P0_CONV (rule
);
19515 case RULE_OP_MANGLE_OVERSTRIKE
:
19516 rule_buf
[rule_pos
] = rule_cmd
;
19517 GET_P0_CONV (rule
);
19521 case RULE_OP_MANGLE_TRUNCATE_AT
:
19522 rule_buf
[rule_pos
] = rule_cmd
;
19523 GET_P0_CONV (rule
);
19526 case RULE_OP_MANGLE_REPLACE
:
19527 rule_buf
[rule_pos
] = rule_cmd
;
19532 case RULE_OP_MANGLE_PURGECHAR
:
19536 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19540 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19541 rule_buf
[rule_pos
] = rule_cmd
;
19542 GET_P0_CONV (rule
);
19545 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19546 rule_buf
[rule_pos
] = rule_cmd
;
19547 GET_P0_CONV (rule
);
19550 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19551 rule_buf
[rule_pos
] = rule_cmd
;
19554 case RULE_OP_MANGLE_SWITCH_FIRST
:
19555 rule_buf
[rule_pos
] = rule_cmd
;
19558 case RULE_OP_MANGLE_SWITCH_LAST
:
19559 rule_buf
[rule_pos
] = rule_cmd
;
19562 case RULE_OP_MANGLE_SWITCH_AT
:
19563 rule_buf
[rule_pos
] = rule_cmd
;
19564 GET_P0_CONV (rule
);
19565 GET_P1_CONV (rule
);
19568 case RULE_OP_MANGLE_CHR_SHIFTL
:
19569 rule_buf
[rule_pos
] = rule_cmd
;
19570 GET_P0_CONV (rule
);
19573 case RULE_OP_MANGLE_CHR_SHIFTR
:
19574 rule_buf
[rule_pos
] = rule_cmd
;
19575 GET_P0_CONV (rule
);
19578 case RULE_OP_MANGLE_CHR_INCR
:
19579 rule_buf
[rule_pos
] = rule_cmd
;
19580 GET_P0_CONV (rule
);
19583 case RULE_OP_MANGLE_CHR_DECR
:
19584 rule_buf
[rule_pos
] = rule_cmd
;
19585 GET_P0_CONV (rule
);
19588 case RULE_OP_MANGLE_REPLACE_NP1
:
19589 rule_buf
[rule_pos
] = rule_cmd
;
19590 GET_P0_CONV (rule
);
19593 case RULE_OP_MANGLE_REPLACE_NM1
:
19594 rule_buf
[rule_pos
] = rule_cmd
;
19595 GET_P0_CONV (rule
);
19598 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19599 rule_buf
[rule_pos
] = rule_cmd
;
19600 GET_P0_CONV (rule
);
19603 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19604 rule_buf
[rule_pos
] = rule_cmd
;
19605 GET_P0_CONV (rule
);
19608 case RULE_OP_MANGLE_TITLE
:
19609 rule_buf
[rule_pos
] = rule_cmd
;
19613 return rule_pos
- 1;
19631 * CPU rules : this is from hashcat sources, cpu based rules
19634 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19635 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19637 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19638 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19639 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19641 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19642 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19643 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19645 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19649 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19654 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19658 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19663 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19667 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19672 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19677 for (l
= 0; l
< arr_len
; l
++)
19679 r
= arr_len
- 1 - l
;
19683 MANGLE_SWITCH (arr
, l
, r
);
19689 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19691 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19693 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19695 return (arr_len
* 2);
19698 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19700 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19702 int orig_len
= arr_len
;
19706 for (i
= 0; i
< times
; i
++)
19708 memcpy (&arr
[arr_len
], arr
, orig_len
);
19710 arr_len
+= orig_len
;
19716 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19718 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19720 mangle_double (arr
, arr_len
);
19722 mangle_reverse (arr
+ arr_len
, arr_len
);
19724 return (arr_len
* 2);
19727 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19732 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19734 MANGLE_SWITCH (arr
, l
, r
);
19740 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19745 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19747 MANGLE_SWITCH (arr
, l
, r
);
19753 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19755 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19759 return (arr_len
+ 1);
19762 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19764 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19768 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19770 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19775 return (arr_len
+ 1);
19778 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19780 if (upos
>= arr_len
) return (arr_len
);
19784 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19786 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19789 return (arr_len
- 1);
19792 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19794 if (upos
>= arr_len
) return (arr_len
);
19796 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19800 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19802 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19808 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19810 if (upos
>= arr_len
) return (arr_len
);
19812 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19816 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19818 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19821 return (arr_len
- ulen
);
19824 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19826 if (upos
>= arr_len
) return (arr_len
);
19828 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19832 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19834 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19839 return (arr_len
+ 1);
19842 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
)
19844 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19846 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19848 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19850 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19852 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19854 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19856 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19858 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19860 return (arr_len
+ arr2_cpy
);
19863 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19865 if (upos
>= arr_len
) return (arr_len
);
19872 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19874 if (upos
>= arr_len
) return (arr_len
);
19876 memset (arr
+ upos
, 0, arr_len
- upos
);
19881 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19885 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19887 if (arr
[arr_pos
] != oldc
) continue;
19889 arr
[arr_pos
] = newc
;
19895 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19901 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19903 if (arr
[arr_pos
] == c
) continue;
19905 arr
[ret_len
] = arr
[arr_pos
];
19913 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19915 if (ulen
> arr_len
) return (arr_len
);
19917 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19921 memcpy (cs
, arr
, ulen
);
19925 for (i
= 0; i
< ulen
; i
++)
19929 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19935 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19937 if (ulen
> arr_len
) return (arr_len
);
19939 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19941 int upos
= arr_len
- ulen
;
19945 for (i
= 0; i
< ulen
; i
++)
19947 char c
= arr
[upos
+ i
];
19949 arr_len
= mangle_append (arr
, arr_len
, c
);
19955 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19957 if ( arr_len
== 0) return (arr_len
);
19958 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19960 char c
= arr
[upos
];
19964 for (i
= 0; i
< ulen
; i
++)
19966 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19972 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19974 if ( arr_len
== 0) return (arr_len
);
19975 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19979 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19981 int new_pos
= arr_pos
* 2;
19983 arr
[new_pos
] = arr
[arr_pos
];
19985 arr
[new_pos
+ 1] = arr
[arr_pos
];
19988 return (arr_len
* 2);
19991 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19993 if (upos
>= arr_len
) return (arr_len
);
19994 if (upos2
>= arr_len
) return (arr_len
);
19996 MANGLE_SWITCH (arr
, upos
, upos2
);
20001 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20003 MANGLE_SWITCH (arr
, upos
, upos2
);
20008 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20010 if (upos
>= arr_len
) return (arr_len
);
20017 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20019 if (upos
>= arr_len
) return (arr_len
);
20026 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20028 if (upos
>= arr_len
) return (arr_len
);
20035 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20037 if (upos
>= arr_len
) return (arr_len
);
20044 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20046 int upper_next
= 1;
20050 for (pos
= 0; pos
< arr_len
; pos
++)
20052 if (arr
[pos
] == ' ')
20063 MANGLE_UPPER_AT (arr
, pos
);
20067 MANGLE_LOWER_AT (arr
, pos
);
20074 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
20076 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20080 uint32_t rule_pos
= 0;
20082 for (j
= 0; j
< rp_gen_num
; j
++)
20089 switch ((char) get_random_num (0, 9))
20092 r
= get_random_num (0, sizeof (grp_op_nop
));
20093 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20097 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20098 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20099 p1
= get_random_num (0, sizeof (grp_pos
));
20100 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20104 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20105 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20106 p1
= get_random_num (1, 6);
20107 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20111 r
= get_random_num (0, sizeof (grp_op_chr
));
20112 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20113 p1
= get_random_num (0x20, 0x7e);
20114 rule_buf
[rule_pos
++] = (char) p1
;
20118 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20119 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20120 p1
= get_random_num (0x20, 0x7e);
20121 rule_buf
[rule_pos
++] = (char) p1
;
20122 p2
= get_random_num (0x20, 0x7e);
20124 p2
= get_random_num (0x20, 0x7e);
20125 rule_buf
[rule_pos
++] = (char) p2
;
20129 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20130 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20131 p1
= get_random_num (0, sizeof (grp_pos
));
20132 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20133 p2
= get_random_num (0x20, 0x7e);
20134 rule_buf
[rule_pos
++] = (char) p2
;
20138 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20139 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20140 p1
= get_random_num (0, sizeof (grp_pos
));
20141 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20142 p2
= get_random_num (0, sizeof (grp_pos
));
20144 p2
= get_random_num (0, sizeof (grp_pos
));
20145 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20149 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20150 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20151 p1
= get_random_num (0, sizeof (grp_pos
));
20152 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20153 p2
= get_random_num (1, sizeof (grp_pos
));
20155 p2
= get_random_num (1, sizeof (grp_pos
));
20156 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20160 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20161 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20162 p1
= get_random_num (0, sizeof (grp_pos
));
20163 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20164 p2
= get_random_num (1, sizeof (grp_pos
));
20165 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20166 p3
= get_random_num (0, sizeof (grp_pos
));
20167 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20175 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20177 char mem
[BLOCK_SIZE
];
20179 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20181 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20183 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
20185 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20187 int out_len
= in_len
;
20188 int mem_len
= in_len
;
20190 memcpy (out
, in
, out_len
);
20194 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20196 int upos
; int upos2
;
20199 switch (rule
[rule_pos
])
20204 case RULE_OP_MANGLE_NOOP
:
20207 case RULE_OP_MANGLE_LREST
:
20208 out_len
= mangle_lrest (out
, out_len
);
20211 case RULE_OP_MANGLE_UREST
:
20212 out_len
= mangle_urest (out
, out_len
);
20215 case RULE_OP_MANGLE_LREST_UFIRST
:
20216 out_len
= mangle_lrest (out
, out_len
);
20217 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20220 case RULE_OP_MANGLE_UREST_LFIRST
:
20221 out_len
= mangle_urest (out
, out_len
);
20222 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20225 case RULE_OP_MANGLE_TREST
:
20226 out_len
= mangle_trest (out
, out_len
);
20229 case RULE_OP_MANGLE_TOGGLE_AT
:
20230 NEXT_RULEPOS (rule_pos
);
20231 NEXT_RPTOI (rule
, rule_pos
, upos
);
20232 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20235 case RULE_OP_MANGLE_REVERSE
:
20236 out_len
= mangle_reverse (out
, out_len
);
20239 case RULE_OP_MANGLE_DUPEWORD
:
20240 out_len
= mangle_double (out
, out_len
);
20243 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20244 NEXT_RULEPOS (rule_pos
);
20245 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20246 out_len
= mangle_double_times (out
, out_len
, ulen
);
20249 case RULE_OP_MANGLE_REFLECT
:
20250 out_len
= mangle_reflect (out
, out_len
);
20253 case RULE_OP_MANGLE_ROTATE_LEFT
:
20254 mangle_rotate_left (out
, out_len
);
20257 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20258 mangle_rotate_right (out
, out_len
);
20261 case RULE_OP_MANGLE_APPEND
:
20262 NEXT_RULEPOS (rule_pos
);
20263 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20266 case RULE_OP_MANGLE_PREPEND
:
20267 NEXT_RULEPOS (rule_pos
);
20268 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20271 case RULE_OP_MANGLE_DELETE_FIRST
:
20272 out_len
= mangle_delete_at (out
, out_len
, 0);
20275 case RULE_OP_MANGLE_DELETE_LAST
:
20276 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20279 case RULE_OP_MANGLE_DELETE_AT
:
20280 NEXT_RULEPOS (rule_pos
);
20281 NEXT_RPTOI (rule
, rule_pos
, upos
);
20282 out_len
= mangle_delete_at (out
, out_len
, upos
);
20285 case RULE_OP_MANGLE_EXTRACT
:
20286 NEXT_RULEPOS (rule_pos
);
20287 NEXT_RPTOI (rule
, rule_pos
, upos
);
20288 NEXT_RULEPOS (rule_pos
);
20289 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20290 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20293 case RULE_OP_MANGLE_OMIT
:
20294 NEXT_RULEPOS (rule_pos
);
20295 NEXT_RPTOI (rule
, rule_pos
, upos
);
20296 NEXT_RULEPOS (rule_pos
);
20297 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20298 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20301 case RULE_OP_MANGLE_INSERT
:
20302 NEXT_RULEPOS (rule_pos
);
20303 NEXT_RPTOI (rule
, rule_pos
, upos
);
20304 NEXT_RULEPOS (rule_pos
);
20305 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20308 case RULE_OP_MANGLE_OVERSTRIKE
:
20309 NEXT_RULEPOS (rule_pos
);
20310 NEXT_RPTOI (rule
, rule_pos
, upos
);
20311 NEXT_RULEPOS (rule_pos
);
20312 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20315 case RULE_OP_MANGLE_TRUNCATE_AT
:
20316 NEXT_RULEPOS (rule_pos
);
20317 NEXT_RPTOI (rule
, rule_pos
, upos
);
20318 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20321 case RULE_OP_MANGLE_REPLACE
:
20322 NEXT_RULEPOS (rule_pos
);
20323 NEXT_RULEPOS (rule_pos
);
20324 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20327 case RULE_OP_MANGLE_PURGECHAR
:
20328 NEXT_RULEPOS (rule_pos
);
20329 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20332 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20336 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20337 NEXT_RULEPOS (rule_pos
);
20338 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20339 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20342 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20343 NEXT_RULEPOS (rule_pos
);
20344 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20345 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20348 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20349 out_len
= mangle_dupechar (out
, out_len
);
20352 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20353 NEXT_RULEPOS (rule_pos
);
20354 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20355 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20358 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20359 NEXT_RULEPOS (rule_pos
);
20360 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20361 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20364 case RULE_OP_MANGLE_SWITCH_FIRST
:
20365 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20368 case RULE_OP_MANGLE_SWITCH_LAST
:
20369 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20372 case RULE_OP_MANGLE_SWITCH_AT
:
20373 NEXT_RULEPOS (rule_pos
);
20374 NEXT_RPTOI (rule
, rule_pos
, upos
);
20375 NEXT_RULEPOS (rule_pos
);
20376 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20377 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20380 case RULE_OP_MANGLE_CHR_SHIFTL
:
20381 NEXT_RULEPOS (rule_pos
);
20382 NEXT_RPTOI (rule
, rule_pos
, upos
);
20383 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20386 case RULE_OP_MANGLE_CHR_SHIFTR
:
20387 NEXT_RULEPOS (rule_pos
);
20388 NEXT_RPTOI (rule
, rule_pos
, upos
);
20389 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20392 case RULE_OP_MANGLE_CHR_INCR
:
20393 NEXT_RULEPOS (rule_pos
);
20394 NEXT_RPTOI (rule
, rule_pos
, upos
);
20395 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20398 case RULE_OP_MANGLE_CHR_DECR
:
20399 NEXT_RULEPOS (rule_pos
);
20400 NEXT_RPTOI (rule
, rule_pos
, upos
);
20401 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20404 case RULE_OP_MANGLE_REPLACE_NP1
:
20405 NEXT_RULEPOS (rule_pos
);
20406 NEXT_RPTOI (rule
, rule_pos
, upos
);
20407 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20410 case RULE_OP_MANGLE_REPLACE_NM1
:
20411 NEXT_RULEPOS (rule_pos
);
20412 NEXT_RPTOI (rule
, rule_pos
, upos
);
20413 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20416 case RULE_OP_MANGLE_TITLE
:
20417 out_len
= mangle_title (out
, out_len
);
20420 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20421 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20422 NEXT_RULEPOS (rule_pos
);
20423 NEXT_RPTOI (rule
, rule_pos
, upos
);
20424 NEXT_RULEPOS (rule_pos
);
20425 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20426 NEXT_RULEPOS (rule_pos
);
20427 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20428 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20431 case RULE_OP_MANGLE_APPEND_MEMORY
:
20432 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20433 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20434 memcpy (out
+ out_len
, mem
, mem_len
);
20435 out_len
+= mem_len
;
20438 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20439 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20440 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20441 memcpy (mem
+ mem_len
, out
, out_len
);
20442 out_len
+= mem_len
;
20443 memcpy (out
, mem
, out_len
);
20446 case RULE_OP_MEMORIZE_WORD
:
20447 memcpy (mem
, out
, out_len
);
20451 case RULE_OP_REJECT_LESS
:
20452 NEXT_RULEPOS (rule_pos
);
20453 NEXT_RPTOI (rule
, rule_pos
, upos
);
20454 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20457 case RULE_OP_REJECT_GREATER
:
20458 NEXT_RULEPOS (rule_pos
);
20459 NEXT_RPTOI (rule
, rule_pos
, upos
);
20460 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20463 case RULE_OP_REJECT_CONTAIN
:
20464 NEXT_RULEPOS (rule_pos
);
20465 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20468 case RULE_OP_REJECT_NOT_CONTAIN
:
20469 NEXT_RULEPOS (rule_pos
);
20470 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20473 case RULE_OP_REJECT_EQUAL_FIRST
:
20474 NEXT_RULEPOS (rule_pos
);
20475 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20478 case RULE_OP_REJECT_EQUAL_LAST
:
20479 NEXT_RULEPOS (rule_pos
);
20480 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20483 case RULE_OP_REJECT_EQUAL_AT
:
20484 NEXT_RULEPOS (rule_pos
);
20485 NEXT_RPTOI (rule
, rule_pos
, upos
);
20486 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20487 NEXT_RULEPOS (rule_pos
);
20488 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20491 case RULE_OP_REJECT_CONTAINS
:
20492 NEXT_RULEPOS (rule_pos
);
20493 NEXT_RPTOI (rule
, rule_pos
, upos
);
20494 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20495 NEXT_RULEPOS (rule_pos
);
20496 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20497 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20500 case RULE_OP_REJECT_MEMORY
:
20501 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20505 return (RULE_RC_SYNTAX_ERROR
);
20510 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);