2 * Author......: Jens Steube <jens.steube@gmail.com>
9 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
10 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
16 #define GET_ACCEL(x) KERNEL_ACCEL_ ## x
17 #define GET_LOOPS(x) KERNEL_LOOPS_ ## x
23 uint32_t rotl32 (const uint32_t a
, const uint n
)
25 return ((a
<< n
) | (a
>> (32 - n
)));
28 uint32_t rotr32 (const uint32_t a
, const uint n
)
30 return ((a
>> n
) | (a
<< (32 - n
)));
33 uint64_t rotl64 (const uint64_t a
, const uint n
)
35 return ((a
<< n
) | (a
>> (64 - n
)));
38 uint64_t rotr64 (const uint64_t a
, const uint n
)
40 return ((a
>> n
) | (a
<< (64 - n
)));
44 * ciphers for use on cpu
51 * hashes for use on cpu
55 #include "cpu-sha256.c"
63 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
69 for (int i
= 0; i
< last_len
; i
++)
79 int max_len
= (int) sizeof (s
);
81 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
83 if (len
> max_len
) len
= max_len
;
85 fwrite (s
, len
, 1, fp
);
92 void log_out_nn (FILE *fp
, const char *fmt
, ...)
94 if (SUPPRESS_OUTPUT
) return;
100 log_final (fp
, fmt
, ap
);
105 void log_info_nn (const char *fmt
, ...)
107 if (SUPPRESS_OUTPUT
) return;
113 log_final (stdout
, fmt
, ap
);
118 void log_error_nn (const char *fmt
, ...)
120 if (SUPPRESS_OUTPUT
) return;
126 log_final (stderr
, fmt
, ap
);
131 void log_out (FILE *fp
, const char *fmt
, ...)
133 if (SUPPRESS_OUTPUT
) return;
139 log_final (fp
, fmt
, ap
);
148 void log_info (const char *fmt
, ...)
150 if (SUPPRESS_OUTPUT
) return;
156 log_final (stdout
, fmt
, ap
);
160 fputc ('\n', stdout
);
165 void log_error (const char *fmt
, ...)
167 if (SUPPRESS_OUTPUT
) return;
169 fputc ('\n', stderr
);
170 fputc ('\n', stderr
);
176 log_final (stderr
, fmt
, ap
);
180 fputc ('\n', stderr
);
181 fputc ('\n', stderr
);
190 uint
byte_swap_32 (const uint n
)
192 return (n
& 0xff000000) >> 24
193 | (n
& 0x00ff0000) >> 8
194 | (n
& 0x0000ff00) << 8
195 | (n
& 0x000000ff) << 24;
198 uint64_t byte_swap_64 (const uint64_t n
)
200 return (n
& 0xff00000000000000ULL
) >> 56
201 | (n
& 0x00ff000000000000ULL
) >> 40
202 | (n
& 0x0000ff0000000000ULL
) >> 24
203 | (n
& 0x000000ff00000000ULL
) >> 8
204 | (n
& 0x00000000ff000000ULL
) << 8
205 | (n
& 0x0000000000ff0000ULL
) << 24
206 | (n
& 0x000000000000ff00ULL
) << 40
207 | (n
& 0x00000000000000ffULL
) << 56;
210 char int_to_base32 (const char c
)
212 static const char tbl
[0x20] =
214 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
215 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
218 return tbl
[(const uint8_t) c
];
221 char base32_to_int (const char c
)
223 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
224 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
229 char int_to_itoa32 (const char c
)
231 static const char tbl
[0x20] =
233 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
234 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
237 return tbl
[(const uint8_t) c
];
240 char itoa32_to_int (const char c
)
242 if ((c
>= '0') && (c
<= '9')) return c
- '0';
243 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
248 char int_to_itoa64 (const char c
)
250 static const char tbl
[0x40] =
252 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
253 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
254 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
255 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
258 return tbl
[(const uint8_t) c
];
261 char itoa64_to_int (const char c
)
263 static const char tbl
[0x100] =
265 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
266 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
267 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
268 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
269 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
270 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
271 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
272 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
273 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
274 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
275 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
276 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
277 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
278 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
279 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
280 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
283 return tbl
[(const uint8_t) c
];
286 char int_to_base64 (const char c
)
288 static const char tbl
[0x40] =
290 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
291 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
292 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
293 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
296 return tbl
[(const uint8_t) c
];
299 char base64_to_int (const char c
)
301 static const char tbl
[0x100] =
303 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
306 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
308 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
310 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 return tbl
[(const uint8_t) c
];
324 char int_to_bf64 (const char c
)
326 static const char tbl
[0x40] =
328 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
329 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
330 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
331 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
334 return tbl
[(const uint8_t) c
];
337 char bf64_to_int (const char c
)
339 static const char tbl
[0x100] =
341 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
344 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
346 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
348 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 return tbl
[(const uint8_t) c
];
362 char int_to_lotus64 (const char c
)
364 if (c
< 10) return '0' + c
;
365 else if (c
< 36) return 'A' + c
- 10;
366 else if (c
< 62) return 'a' + c
- 36;
367 else if (c
== 62) return '+';
368 else if (c
== 63) return '/';
373 char lotus64_to_int (const char c
)
375 if ((c
>= '0') && (c
<= '9')) return c
- '0';
376 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
377 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
378 else if (c
== '+') return 62;
379 else if (c
== '/') return 63;
385 int base32_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
387 char *in_ptr
= in_buf
;
389 char *out_ptr
= out_buf
;
391 for (int i
= 0; i
< in_len
; i
+= 8)
393 char out_val0
= f (in_ptr
[0] & 0x7f);
394 char out_val1
= f (in_ptr
[1] & 0x7f);
395 char out_val2
= f (in_ptr
[2] & 0x7f);
396 char out_val3
= f (in_ptr
[3] & 0x7f);
397 char out_val4
= f (in_ptr
[4] & 0x7f);
398 char out_val5
= f (in_ptr
[5] & 0x7f);
399 char out_val6
= f (in_ptr
[6] & 0x7f);
400 char out_val7
= f (in_ptr
[7] & 0x7f);
402 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
403 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
404 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
405 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
406 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
412 for (int i
= 0; i
< in_len
; i
++)
414 if (in_buf
[i
] != '=') continue;
419 int out_len
= (in_len
* 5) / 8;
424 int base32_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
426 char *in_ptr
= in_buf
;
428 char *out_ptr
= out_buf
;
430 for (int i
= 0; i
< in_len
; i
+= 5)
432 char out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
433 char out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
434 char out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
435 char out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
436 char out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
437 char out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
438 char out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
439 char out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
441 out_ptr
[0] = out_val0
& 0x7f;
442 out_ptr
[1] = out_val1
& 0x7f;
443 out_ptr
[2] = out_val2
& 0x7f;
444 out_ptr
[3] = out_val3
& 0x7f;
445 out_ptr
[4] = out_val4
& 0x7f;
446 out_ptr
[5] = out_val5
& 0x7f;
447 out_ptr
[6] = out_val6
& 0x7f;
448 out_ptr
[7] = out_val7
& 0x7f;
454 int out_len
= (in_len
* 8) / 5;
456 for (int i
= 0; i
< (7 - (in_len
% 7)); i
++)
460 out_buf
[out_len
] = '=';
466 int base64_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
468 char *in_ptr
= in_buf
;
470 char *out_ptr
= out_buf
;
472 for (int i
= 0; i
< in_len
; i
+= 4)
474 char out_val0
= f (in_ptr
[0] & 0x7f);
475 char out_val1
= f (in_ptr
[1] & 0x7f);
476 char out_val2
= f (in_ptr
[2] & 0x7f);
477 char out_val3
= f (in_ptr
[3] & 0x7f);
479 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
480 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
481 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
487 for (int i
= 0; i
< in_len
; i
++)
489 if (in_buf
[i
] != '=') continue;
494 int out_len
= (in_len
* 6) / 8;
499 int base64_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
501 char *in_ptr
= in_buf
;
503 char *out_ptr
= out_buf
;
505 for (int i
= 0; i
< in_len
; i
+= 3)
507 char out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
508 char out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
509 char out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
510 char out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
512 out_ptr
[0] = out_val0
& 0x7f;
513 out_ptr
[1] = out_val1
& 0x7f;
514 out_ptr
[2] = out_val2
& 0x7f;
515 out_ptr
[3] = out_val3
& 0x7f;
521 int out_len
= (in_len
* 8) / 6;
523 for (int i
= 0; i
< (3 - (in_len
% 3)); i
++)
527 out_buf
[out_len
] = '=';
533 static void AES128_decrypt_cbc (const uint key
[4], const uint iv
[4], const uint in
[16], uint out
[16])
537 AES_set_decrypt_key ((unsigned char *) key
, 128, &skey
);
546 for (int i
= 0; i
< 16; i
+= 4)
556 AES_decrypt (&skey
, (char *) _in
, (char *) _out
);
563 out
[i
+ 0] = _out
[0];
564 out
[i
+ 1] = _out
[1];
565 out
[i
+ 2] = _out
[2];
566 out
[i
+ 3] = _out
[3];
575 static void juniper_decrypt_hash (char *in
, char *out
)
579 char base64_buf
[100];
581 memset (base64_buf
, 0, sizeof (base64_buf
));
583 base64_decode (base64_to_int
, in
, DISPLAY_LEN_MIN_501
, base64_buf
);
587 uint juniper_iv
[4] = { 0 };
589 memcpy (juniper_iv
, base64_buf
, 12);
591 memcpy (out
, juniper_iv
, 12);
597 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
598 juniper_key
[1] = byte_swap_32 (0x8df91059);
599 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
600 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
604 uint
*in_ptr
= (uint
*) (base64_buf
+ 12);
605 uint
*out_ptr
= (uint
*) (out
+ 12);
607 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
610 uint
is_valid_hex_char (const char c
)
612 if ((c
>= '0') && (c
<= '9')) return 1;
613 if ((c
>= 'A') && (c
<= 'F')) return 1;
614 if ((c
>= 'a') && (c
<= 'f')) return 1;
619 char hex_convert (const char c
)
621 return (c
& 15) + (c
>> 6) * 9;
624 char hex_to_char (const char hex
[2])
628 v
|= (hex_convert (hex
[1]) << 0);
629 v
|= (hex_convert (hex
[0]) << 4);
634 uint
hex_to_uint (const char hex
[8])
638 v
|= hex_convert (hex
[7]) << 0;
639 v
|= hex_convert (hex
[6]) << 4;
640 v
|= hex_convert (hex
[5]) << 8;
641 v
|= hex_convert (hex
[4]) << 12;
642 v
|= hex_convert (hex
[3]) << 16;
643 v
|= hex_convert (hex
[2]) << 20;
644 v
|= hex_convert (hex
[1]) << 24;
645 v
|= hex_convert (hex
[0]) << 28;
650 uint64_t hex_to_uint64_t (const char hex
[16])
654 v
|= ((uint64_t) hex_convert (hex
[15]) << 0);
655 v
|= ((uint64_t) hex_convert (hex
[14]) << 4);
656 v
|= ((uint64_t) hex_convert (hex
[13]) << 8);
657 v
|= ((uint64_t) hex_convert (hex
[12]) << 12);
658 v
|= ((uint64_t) hex_convert (hex
[11]) << 16);
659 v
|= ((uint64_t) hex_convert (hex
[10]) << 20);
660 v
|= ((uint64_t) hex_convert (hex
[ 9]) << 24);
661 v
|= ((uint64_t) hex_convert (hex
[ 8]) << 28);
662 v
|= ((uint64_t) hex_convert (hex
[ 7]) << 32);
663 v
|= ((uint64_t) hex_convert (hex
[ 6]) << 36);
664 v
|= ((uint64_t) hex_convert (hex
[ 5]) << 40);
665 v
|= ((uint64_t) hex_convert (hex
[ 4]) << 44);
666 v
|= ((uint64_t) hex_convert (hex
[ 3]) << 48);
667 v
|= ((uint64_t) hex_convert (hex
[ 2]) << 52);
668 v
|= ((uint64_t) hex_convert (hex
[ 1]) << 56);
669 v
|= ((uint64_t) hex_convert (hex
[ 0]) << 60);
674 void bin_to_hex_lower (uint v
, char hex
[8])
676 hex
[0] = v
>> 28 & 15;
677 hex
[1] = v
>> 24 & 15;
678 hex
[2] = v
>> 20 & 15;
679 hex
[3] = v
>> 16 & 15;
680 hex
[4] = v
>> 12 & 15;
681 hex
[5] = v
>> 8 & 15;
682 hex
[6] = v
>> 4 & 15;
683 hex
[7] = v
>> 0 & 15;
687 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
688 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
689 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
690 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
691 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
692 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
693 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
694 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
697 void phpass_decode (unsigned char digest
[16], unsigned char buf
[22])
701 l
= itoa64_to_int (buf
[ 0]) << 0;
702 l
|= itoa64_to_int (buf
[ 1]) << 6;
703 l
|= itoa64_to_int (buf
[ 2]) << 12;
704 l
|= itoa64_to_int (buf
[ 3]) << 18;
706 digest
[ 0] = (l
>> 0) & 0xff;
707 digest
[ 1] = (l
>> 8) & 0xff;
708 digest
[ 2] = (l
>> 16) & 0xff;
710 l
= itoa64_to_int (buf
[ 4]) << 0;
711 l
|= itoa64_to_int (buf
[ 5]) << 6;
712 l
|= itoa64_to_int (buf
[ 6]) << 12;
713 l
|= itoa64_to_int (buf
[ 7]) << 18;
715 digest
[ 3] = (l
>> 0) & 0xff;
716 digest
[ 4] = (l
>> 8) & 0xff;
717 digest
[ 5] = (l
>> 16) & 0xff;
719 l
= itoa64_to_int (buf
[ 8]) << 0;
720 l
|= itoa64_to_int (buf
[ 9]) << 6;
721 l
|= itoa64_to_int (buf
[10]) << 12;
722 l
|= itoa64_to_int (buf
[11]) << 18;
724 digest
[ 6] = (l
>> 0) & 0xff;
725 digest
[ 7] = (l
>> 8) & 0xff;
726 digest
[ 8] = (l
>> 16) & 0xff;
728 l
= itoa64_to_int (buf
[12]) << 0;
729 l
|= itoa64_to_int (buf
[13]) << 6;
730 l
|= itoa64_to_int (buf
[14]) << 12;
731 l
|= itoa64_to_int (buf
[15]) << 18;
733 digest
[ 9] = (l
>> 0) & 0xff;
734 digest
[10] = (l
>> 8) & 0xff;
735 digest
[11] = (l
>> 16) & 0xff;
737 l
= itoa64_to_int (buf
[16]) << 0;
738 l
|= itoa64_to_int (buf
[17]) << 6;
739 l
|= itoa64_to_int (buf
[18]) << 12;
740 l
|= itoa64_to_int (buf
[19]) << 18;
742 digest
[12] = (l
>> 0) & 0xff;
743 digest
[13] = (l
>> 8) & 0xff;
744 digest
[14] = (l
>> 16) & 0xff;
746 l
= itoa64_to_int (buf
[20]) << 0;
747 l
|= itoa64_to_int (buf
[21]) << 6;
749 digest
[15] = (l
>> 0) & 0xff;
752 void phpass_encode (unsigned char digest
[16], unsigned char buf
[22])
756 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
758 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
759 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
760 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
761 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
763 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
765 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
767 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
768 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
770 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
772 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
774 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
775 buf
[11] = int_to_itoa64 (l
& 0x3f);
777 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
779 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
781 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
782 buf
[15] = int_to_itoa64 (l
& 0x3f);
784 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
786 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
788 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
789 buf
[19] = int_to_itoa64 (l
& 0x3f);
791 l
= (digest
[15] << 0);
793 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[21] = int_to_itoa64 (l
& 0x3f);
797 void md5crypt_decode (unsigned char digest
[16], unsigned char buf
[22])
801 l
= itoa64_to_int (buf
[ 0]) << 0;
802 l
|= itoa64_to_int (buf
[ 1]) << 6;
803 l
|= itoa64_to_int (buf
[ 2]) << 12;
804 l
|= itoa64_to_int (buf
[ 3]) << 18;
806 digest
[ 0] = (l
>> 16) & 0xff;
807 digest
[ 6] = (l
>> 8) & 0xff;
808 digest
[12] = (l
>> 0) & 0xff;
810 l
= itoa64_to_int (buf
[ 4]) << 0;
811 l
|= itoa64_to_int (buf
[ 5]) << 6;
812 l
|= itoa64_to_int (buf
[ 6]) << 12;
813 l
|= itoa64_to_int (buf
[ 7]) << 18;
815 digest
[ 1] = (l
>> 16) & 0xff;
816 digest
[ 7] = (l
>> 8) & 0xff;
817 digest
[13] = (l
>> 0) & 0xff;
819 l
= itoa64_to_int (buf
[ 8]) << 0;
820 l
|= itoa64_to_int (buf
[ 9]) << 6;
821 l
|= itoa64_to_int (buf
[10]) << 12;
822 l
|= itoa64_to_int (buf
[11]) << 18;
824 digest
[ 2] = (l
>> 16) & 0xff;
825 digest
[ 8] = (l
>> 8) & 0xff;
826 digest
[14] = (l
>> 0) & 0xff;
828 l
= itoa64_to_int (buf
[12]) << 0;
829 l
|= itoa64_to_int (buf
[13]) << 6;
830 l
|= itoa64_to_int (buf
[14]) << 12;
831 l
|= itoa64_to_int (buf
[15]) << 18;
833 digest
[ 3] = (l
>> 16) & 0xff;
834 digest
[ 9] = (l
>> 8) & 0xff;
835 digest
[15] = (l
>> 0) & 0xff;
837 l
= itoa64_to_int (buf
[16]) << 0;
838 l
|= itoa64_to_int (buf
[17]) << 6;
839 l
|= itoa64_to_int (buf
[18]) << 12;
840 l
|= itoa64_to_int (buf
[19]) << 18;
842 digest
[ 4] = (l
>> 16) & 0xff;
843 digest
[10] = (l
>> 8) & 0xff;
844 digest
[ 5] = (l
>> 0) & 0xff;
846 l
= itoa64_to_int (buf
[20]) << 0;
847 l
|= itoa64_to_int (buf
[21]) << 6;
849 digest
[11] = (l
>> 0) & 0xff;
852 void md5crypt_encode (unsigned char digest
[16], unsigned char buf
[22])
856 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
858 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
859 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
860 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
861 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
865 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
872 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
879 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
886 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 l
= (digest
[11] << 0);
893 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
897 void sha512crypt_decode (unsigned char digest
[64], unsigned char buf
[86])
901 l
= itoa64_to_int (buf
[ 0]) << 0;
902 l
|= itoa64_to_int (buf
[ 1]) << 6;
903 l
|= itoa64_to_int (buf
[ 2]) << 12;
904 l
|= itoa64_to_int (buf
[ 3]) << 18;
906 digest
[ 0] = (l
>> 16) & 0xff;
907 digest
[21] = (l
>> 8) & 0xff;
908 digest
[42] = (l
>> 0) & 0xff;
910 l
= itoa64_to_int (buf
[ 4]) << 0;
911 l
|= itoa64_to_int (buf
[ 5]) << 6;
912 l
|= itoa64_to_int (buf
[ 6]) << 12;
913 l
|= itoa64_to_int (buf
[ 7]) << 18;
915 digest
[22] = (l
>> 16) & 0xff;
916 digest
[43] = (l
>> 8) & 0xff;
917 digest
[ 1] = (l
>> 0) & 0xff;
919 l
= itoa64_to_int (buf
[ 8]) << 0;
920 l
|= itoa64_to_int (buf
[ 9]) << 6;
921 l
|= itoa64_to_int (buf
[10]) << 12;
922 l
|= itoa64_to_int (buf
[11]) << 18;
924 digest
[44] = (l
>> 16) & 0xff;
925 digest
[ 2] = (l
>> 8) & 0xff;
926 digest
[23] = (l
>> 0) & 0xff;
928 l
= itoa64_to_int (buf
[12]) << 0;
929 l
|= itoa64_to_int (buf
[13]) << 6;
930 l
|= itoa64_to_int (buf
[14]) << 12;
931 l
|= itoa64_to_int (buf
[15]) << 18;
933 digest
[ 3] = (l
>> 16) & 0xff;
934 digest
[24] = (l
>> 8) & 0xff;
935 digest
[45] = (l
>> 0) & 0xff;
937 l
= itoa64_to_int (buf
[16]) << 0;
938 l
|= itoa64_to_int (buf
[17]) << 6;
939 l
|= itoa64_to_int (buf
[18]) << 12;
940 l
|= itoa64_to_int (buf
[19]) << 18;
942 digest
[25] = (l
>> 16) & 0xff;
943 digest
[46] = (l
>> 8) & 0xff;
944 digest
[ 4] = (l
>> 0) & 0xff;
946 l
= itoa64_to_int (buf
[20]) << 0;
947 l
|= itoa64_to_int (buf
[21]) << 6;
948 l
|= itoa64_to_int (buf
[22]) << 12;
949 l
|= itoa64_to_int (buf
[23]) << 18;
951 digest
[47] = (l
>> 16) & 0xff;
952 digest
[ 5] = (l
>> 8) & 0xff;
953 digest
[26] = (l
>> 0) & 0xff;
955 l
= itoa64_to_int (buf
[24]) << 0;
956 l
|= itoa64_to_int (buf
[25]) << 6;
957 l
|= itoa64_to_int (buf
[26]) << 12;
958 l
|= itoa64_to_int (buf
[27]) << 18;
960 digest
[ 6] = (l
>> 16) & 0xff;
961 digest
[27] = (l
>> 8) & 0xff;
962 digest
[48] = (l
>> 0) & 0xff;
964 l
= itoa64_to_int (buf
[28]) << 0;
965 l
|= itoa64_to_int (buf
[29]) << 6;
966 l
|= itoa64_to_int (buf
[30]) << 12;
967 l
|= itoa64_to_int (buf
[31]) << 18;
969 digest
[28] = (l
>> 16) & 0xff;
970 digest
[49] = (l
>> 8) & 0xff;
971 digest
[ 7] = (l
>> 0) & 0xff;
973 l
= itoa64_to_int (buf
[32]) << 0;
974 l
|= itoa64_to_int (buf
[33]) << 6;
975 l
|= itoa64_to_int (buf
[34]) << 12;
976 l
|= itoa64_to_int (buf
[35]) << 18;
978 digest
[50] = (l
>> 16) & 0xff;
979 digest
[ 8] = (l
>> 8) & 0xff;
980 digest
[29] = (l
>> 0) & 0xff;
982 l
= itoa64_to_int (buf
[36]) << 0;
983 l
|= itoa64_to_int (buf
[37]) << 6;
984 l
|= itoa64_to_int (buf
[38]) << 12;
985 l
|= itoa64_to_int (buf
[39]) << 18;
987 digest
[ 9] = (l
>> 16) & 0xff;
988 digest
[30] = (l
>> 8) & 0xff;
989 digest
[51] = (l
>> 0) & 0xff;
991 l
= itoa64_to_int (buf
[40]) << 0;
992 l
|= itoa64_to_int (buf
[41]) << 6;
993 l
|= itoa64_to_int (buf
[42]) << 12;
994 l
|= itoa64_to_int (buf
[43]) << 18;
996 digest
[31] = (l
>> 16) & 0xff;
997 digest
[52] = (l
>> 8) & 0xff;
998 digest
[10] = (l
>> 0) & 0xff;
1000 l
= itoa64_to_int (buf
[44]) << 0;
1001 l
|= itoa64_to_int (buf
[45]) << 6;
1002 l
|= itoa64_to_int (buf
[46]) << 12;
1003 l
|= itoa64_to_int (buf
[47]) << 18;
1005 digest
[53] = (l
>> 16) & 0xff;
1006 digest
[11] = (l
>> 8) & 0xff;
1007 digest
[32] = (l
>> 0) & 0xff;
1009 l
= itoa64_to_int (buf
[48]) << 0;
1010 l
|= itoa64_to_int (buf
[49]) << 6;
1011 l
|= itoa64_to_int (buf
[50]) << 12;
1012 l
|= itoa64_to_int (buf
[51]) << 18;
1014 digest
[12] = (l
>> 16) & 0xff;
1015 digest
[33] = (l
>> 8) & 0xff;
1016 digest
[54] = (l
>> 0) & 0xff;
1018 l
= itoa64_to_int (buf
[52]) << 0;
1019 l
|= itoa64_to_int (buf
[53]) << 6;
1020 l
|= itoa64_to_int (buf
[54]) << 12;
1021 l
|= itoa64_to_int (buf
[55]) << 18;
1023 digest
[34] = (l
>> 16) & 0xff;
1024 digest
[55] = (l
>> 8) & 0xff;
1025 digest
[13] = (l
>> 0) & 0xff;
1027 l
= itoa64_to_int (buf
[56]) << 0;
1028 l
|= itoa64_to_int (buf
[57]) << 6;
1029 l
|= itoa64_to_int (buf
[58]) << 12;
1030 l
|= itoa64_to_int (buf
[59]) << 18;
1032 digest
[56] = (l
>> 16) & 0xff;
1033 digest
[14] = (l
>> 8) & 0xff;
1034 digest
[35] = (l
>> 0) & 0xff;
1036 l
= itoa64_to_int (buf
[60]) << 0;
1037 l
|= itoa64_to_int (buf
[61]) << 6;
1038 l
|= itoa64_to_int (buf
[62]) << 12;
1039 l
|= itoa64_to_int (buf
[63]) << 18;
1041 digest
[15] = (l
>> 16) & 0xff;
1042 digest
[36] = (l
>> 8) & 0xff;
1043 digest
[57] = (l
>> 0) & 0xff;
1045 l
= itoa64_to_int (buf
[64]) << 0;
1046 l
|= itoa64_to_int (buf
[65]) << 6;
1047 l
|= itoa64_to_int (buf
[66]) << 12;
1048 l
|= itoa64_to_int (buf
[67]) << 18;
1050 digest
[37] = (l
>> 16) & 0xff;
1051 digest
[58] = (l
>> 8) & 0xff;
1052 digest
[16] = (l
>> 0) & 0xff;
1054 l
= itoa64_to_int (buf
[68]) << 0;
1055 l
|= itoa64_to_int (buf
[69]) << 6;
1056 l
|= itoa64_to_int (buf
[70]) << 12;
1057 l
|= itoa64_to_int (buf
[71]) << 18;
1059 digest
[59] = (l
>> 16) & 0xff;
1060 digest
[17] = (l
>> 8) & 0xff;
1061 digest
[38] = (l
>> 0) & 0xff;
1063 l
= itoa64_to_int (buf
[72]) << 0;
1064 l
|= itoa64_to_int (buf
[73]) << 6;
1065 l
|= itoa64_to_int (buf
[74]) << 12;
1066 l
|= itoa64_to_int (buf
[75]) << 18;
1068 digest
[18] = (l
>> 16) & 0xff;
1069 digest
[39] = (l
>> 8) & 0xff;
1070 digest
[60] = (l
>> 0) & 0xff;
1072 l
= itoa64_to_int (buf
[76]) << 0;
1073 l
|= itoa64_to_int (buf
[77]) << 6;
1074 l
|= itoa64_to_int (buf
[78]) << 12;
1075 l
|= itoa64_to_int (buf
[79]) << 18;
1077 digest
[40] = (l
>> 16) & 0xff;
1078 digest
[61] = (l
>> 8) & 0xff;
1079 digest
[19] = (l
>> 0) & 0xff;
1081 l
= itoa64_to_int (buf
[80]) << 0;
1082 l
|= itoa64_to_int (buf
[81]) << 6;
1083 l
|= itoa64_to_int (buf
[82]) << 12;
1084 l
|= itoa64_to_int (buf
[83]) << 18;
1086 digest
[62] = (l
>> 16) & 0xff;
1087 digest
[20] = (l
>> 8) & 0xff;
1088 digest
[41] = (l
>> 0) & 0xff;
1090 l
= itoa64_to_int (buf
[84]) << 0;
1091 l
|= itoa64_to_int (buf
[85]) << 6;
1093 digest
[63] = (l
>> 0) & 0xff;
1096 void sha512crypt_encode (unsigned char digest
[64], unsigned char buf
[86])
1100 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1102 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1103 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1104 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1105 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1109 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1116 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1123 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1130 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1137 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1144 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1151 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1158 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1165 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1172 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1179 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1186 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1193 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1200 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1207 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1214 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1221 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1228 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1235 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1242 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 l
= 0 | 0 | (digest
[63] << 0);
1249 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1253 void sha1aix_decode (unsigned char digest
[20], unsigned char buf
[27])
1257 l
= itoa64_to_int (buf
[ 0]) << 0;
1258 l
|= itoa64_to_int (buf
[ 1]) << 6;
1259 l
|= itoa64_to_int (buf
[ 2]) << 12;
1260 l
|= itoa64_to_int (buf
[ 3]) << 18;
1262 digest
[ 2] = (l
>> 0) & 0xff;
1263 digest
[ 1] = (l
>> 8) & 0xff;
1264 digest
[ 0] = (l
>> 16) & 0xff;
1266 l
= itoa64_to_int (buf
[ 4]) << 0;
1267 l
|= itoa64_to_int (buf
[ 5]) << 6;
1268 l
|= itoa64_to_int (buf
[ 6]) << 12;
1269 l
|= itoa64_to_int (buf
[ 7]) << 18;
1271 digest
[ 5] = (l
>> 0) & 0xff;
1272 digest
[ 4] = (l
>> 8) & 0xff;
1273 digest
[ 3] = (l
>> 16) & 0xff;
1275 l
= itoa64_to_int (buf
[ 8]) << 0;
1276 l
|= itoa64_to_int (buf
[ 9]) << 6;
1277 l
|= itoa64_to_int (buf
[10]) << 12;
1278 l
|= itoa64_to_int (buf
[11]) << 18;
1280 digest
[ 8] = (l
>> 0) & 0xff;
1281 digest
[ 7] = (l
>> 8) & 0xff;
1282 digest
[ 6] = (l
>> 16) & 0xff;
1284 l
= itoa64_to_int (buf
[12]) << 0;
1285 l
|= itoa64_to_int (buf
[13]) << 6;
1286 l
|= itoa64_to_int (buf
[14]) << 12;
1287 l
|= itoa64_to_int (buf
[15]) << 18;
1289 digest
[11] = (l
>> 0) & 0xff;
1290 digest
[10] = (l
>> 8) & 0xff;
1291 digest
[ 9] = (l
>> 16) & 0xff;
1293 l
= itoa64_to_int (buf
[16]) << 0;
1294 l
|= itoa64_to_int (buf
[17]) << 6;
1295 l
|= itoa64_to_int (buf
[18]) << 12;
1296 l
|= itoa64_to_int (buf
[19]) << 18;
1298 digest
[14] = (l
>> 0) & 0xff;
1299 digest
[13] = (l
>> 8) & 0xff;
1300 digest
[12] = (l
>> 16) & 0xff;
1302 l
= itoa64_to_int (buf
[20]) << 0;
1303 l
|= itoa64_to_int (buf
[21]) << 6;
1304 l
|= itoa64_to_int (buf
[22]) << 12;
1305 l
|= itoa64_to_int (buf
[23]) << 18;
1307 digest
[17] = (l
>> 0) & 0xff;
1308 digest
[16] = (l
>> 8) & 0xff;
1309 digest
[15] = (l
>> 16) & 0xff;
1311 l
= itoa64_to_int (buf
[24]) << 0;
1312 l
|= itoa64_to_int (buf
[25]) << 6;
1313 l
|= itoa64_to_int (buf
[26]) << 12;
1315 digest
[19] = (l
>> 8) & 0xff;
1316 digest
[18] = (l
>> 16) & 0xff;
1319 void sha1aix_encode (unsigned char digest
[20], unsigned char buf
[27])
1323 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1325 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1326 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1327 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1328 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1330 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1332 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1334 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1335 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1337 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1339 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1341 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1342 buf
[11] = int_to_itoa64 (l
& 0x3f);
1344 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1346 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1348 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1349 buf
[15] = int_to_itoa64 (l
& 0x3f);
1351 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1353 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1355 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1356 buf
[19] = int_to_itoa64 (l
& 0x3f);
1358 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1360 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1362 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1363 buf
[23] = int_to_itoa64 (l
& 0x3f);
1365 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1367 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1369 buf
[26] = int_to_itoa64 (l
& 0x3f);
1372 void sha256aix_decode (unsigned char digest
[32], unsigned char buf
[43])
1376 l
= itoa64_to_int (buf
[ 0]) << 0;
1377 l
|= itoa64_to_int (buf
[ 1]) << 6;
1378 l
|= itoa64_to_int (buf
[ 2]) << 12;
1379 l
|= itoa64_to_int (buf
[ 3]) << 18;
1381 digest
[ 2] = (l
>> 0) & 0xff;
1382 digest
[ 1] = (l
>> 8) & 0xff;
1383 digest
[ 0] = (l
>> 16) & 0xff;
1385 l
= itoa64_to_int (buf
[ 4]) << 0;
1386 l
|= itoa64_to_int (buf
[ 5]) << 6;
1387 l
|= itoa64_to_int (buf
[ 6]) << 12;
1388 l
|= itoa64_to_int (buf
[ 7]) << 18;
1390 digest
[ 5] = (l
>> 0) & 0xff;
1391 digest
[ 4] = (l
>> 8) & 0xff;
1392 digest
[ 3] = (l
>> 16) & 0xff;
1394 l
= itoa64_to_int (buf
[ 8]) << 0;
1395 l
|= itoa64_to_int (buf
[ 9]) << 6;
1396 l
|= itoa64_to_int (buf
[10]) << 12;
1397 l
|= itoa64_to_int (buf
[11]) << 18;
1399 digest
[ 8] = (l
>> 0) & 0xff;
1400 digest
[ 7] = (l
>> 8) & 0xff;
1401 digest
[ 6] = (l
>> 16) & 0xff;
1403 l
= itoa64_to_int (buf
[12]) << 0;
1404 l
|= itoa64_to_int (buf
[13]) << 6;
1405 l
|= itoa64_to_int (buf
[14]) << 12;
1406 l
|= itoa64_to_int (buf
[15]) << 18;
1408 digest
[11] = (l
>> 0) & 0xff;
1409 digest
[10] = (l
>> 8) & 0xff;
1410 digest
[ 9] = (l
>> 16) & 0xff;
1412 l
= itoa64_to_int (buf
[16]) << 0;
1413 l
|= itoa64_to_int (buf
[17]) << 6;
1414 l
|= itoa64_to_int (buf
[18]) << 12;
1415 l
|= itoa64_to_int (buf
[19]) << 18;
1417 digest
[14] = (l
>> 0) & 0xff;
1418 digest
[13] = (l
>> 8) & 0xff;
1419 digest
[12] = (l
>> 16) & 0xff;
1421 l
= itoa64_to_int (buf
[20]) << 0;
1422 l
|= itoa64_to_int (buf
[21]) << 6;
1423 l
|= itoa64_to_int (buf
[22]) << 12;
1424 l
|= itoa64_to_int (buf
[23]) << 18;
1426 digest
[17] = (l
>> 0) & 0xff;
1427 digest
[16] = (l
>> 8) & 0xff;
1428 digest
[15] = (l
>> 16) & 0xff;
1430 l
= itoa64_to_int (buf
[24]) << 0;
1431 l
|= itoa64_to_int (buf
[25]) << 6;
1432 l
|= itoa64_to_int (buf
[26]) << 12;
1433 l
|= itoa64_to_int (buf
[27]) << 18;
1435 digest
[20] = (l
>> 0) & 0xff;
1436 digest
[19] = (l
>> 8) & 0xff;
1437 digest
[18] = (l
>> 16) & 0xff;
1439 l
= itoa64_to_int (buf
[28]) << 0;
1440 l
|= itoa64_to_int (buf
[29]) << 6;
1441 l
|= itoa64_to_int (buf
[30]) << 12;
1442 l
|= itoa64_to_int (buf
[31]) << 18;
1444 digest
[23] = (l
>> 0) & 0xff;
1445 digest
[22] = (l
>> 8) & 0xff;
1446 digest
[21] = (l
>> 16) & 0xff;
1448 l
= itoa64_to_int (buf
[32]) << 0;
1449 l
|= itoa64_to_int (buf
[33]) << 6;
1450 l
|= itoa64_to_int (buf
[34]) << 12;
1451 l
|= itoa64_to_int (buf
[35]) << 18;
1453 digest
[26] = (l
>> 0) & 0xff;
1454 digest
[25] = (l
>> 8) & 0xff;
1455 digest
[24] = (l
>> 16) & 0xff;
1457 l
= itoa64_to_int (buf
[36]) << 0;
1458 l
|= itoa64_to_int (buf
[37]) << 6;
1459 l
|= itoa64_to_int (buf
[38]) << 12;
1460 l
|= itoa64_to_int (buf
[39]) << 18;
1462 digest
[29] = (l
>> 0) & 0xff;
1463 digest
[28] = (l
>> 8) & 0xff;
1464 digest
[27] = (l
>> 16) & 0xff;
1466 l
= itoa64_to_int (buf
[40]) << 0;
1467 l
|= itoa64_to_int (buf
[41]) << 6;
1468 l
|= itoa64_to_int (buf
[42]) << 12;
1470 //digest[32] = (l >> 0) & 0xff;
1471 digest
[31] = (l
>> 8) & 0xff;
1472 digest
[30] = (l
>> 16) & 0xff;
1475 void sha256aix_encode (unsigned char digest
[32], unsigned char buf
[43])
1479 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1481 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1482 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1483 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1484 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1486 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1488 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1490 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1491 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1493 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1495 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1497 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1498 buf
[11] = int_to_itoa64 (l
& 0x3f);
1500 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1502 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1504 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1505 buf
[15] = int_to_itoa64 (l
& 0x3f);
1507 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1509 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1511 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1512 buf
[19] = int_to_itoa64 (l
& 0x3f);
1514 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1516 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1518 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1519 buf
[23] = int_to_itoa64 (l
& 0x3f);
1521 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1523 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1525 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1526 buf
[27] = int_to_itoa64 (l
& 0x3f);
1528 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1530 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1532 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1533 buf
[31] = int_to_itoa64 (l
& 0x3f);
1535 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1537 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1539 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1540 buf
[35] = int_to_itoa64 (l
& 0x3f);
1542 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1544 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1546 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1547 buf
[39] = int_to_itoa64 (l
& 0x3f);
1549 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1551 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1553 buf
[42] = int_to_itoa64 (l
& 0x3f);
1556 void sha512aix_decode (unsigned char digest
[64], unsigned char buf
[86])
1560 l
= itoa64_to_int (buf
[ 0]) << 0;
1561 l
|= itoa64_to_int (buf
[ 1]) << 6;
1562 l
|= itoa64_to_int (buf
[ 2]) << 12;
1563 l
|= itoa64_to_int (buf
[ 3]) << 18;
1565 digest
[ 2] = (l
>> 0) & 0xff;
1566 digest
[ 1] = (l
>> 8) & 0xff;
1567 digest
[ 0] = (l
>> 16) & 0xff;
1569 l
= itoa64_to_int (buf
[ 4]) << 0;
1570 l
|= itoa64_to_int (buf
[ 5]) << 6;
1571 l
|= itoa64_to_int (buf
[ 6]) << 12;
1572 l
|= itoa64_to_int (buf
[ 7]) << 18;
1574 digest
[ 5] = (l
>> 0) & 0xff;
1575 digest
[ 4] = (l
>> 8) & 0xff;
1576 digest
[ 3] = (l
>> 16) & 0xff;
1578 l
= itoa64_to_int (buf
[ 8]) << 0;
1579 l
|= itoa64_to_int (buf
[ 9]) << 6;
1580 l
|= itoa64_to_int (buf
[10]) << 12;
1581 l
|= itoa64_to_int (buf
[11]) << 18;
1583 digest
[ 8] = (l
>> 0) & 0xff;
1584 digest
[ 7] = (l
>> 8) & 0xff;
1585 digest
[ 6] = (l
>> 16) & 0xff;
1587 l
= itoa64_to_int (buf
[12]) << 0;
1588 l
|= itoa64_to_int (buf
[13]) << 6;
1589 l
|= itoa64_to_int (buf
[14]) << 12;
1590 l
|= itoa64_to_int (buf
[15]) << 18;
1592 digest
[11] = (l
>> 0) & 0xff;
1593 digest
[10] = (l
>> 8) & 0xff;
1594 digest
[ 9] = (l
>> 16) & 0xff;
1596 l
= itoa64_to_int (buf
[16]) << 0;
1597 l
|= itoa64_to_int (buf
[17]) << 6;
1598 l
|= itoa64_to_int (buf
[18]) << 12;
1599 l
|= itoa64_to_int (buf
[19]) << 18;
1601 digest
[14] = (l
>> 0) & 0xff;
1602 digest
[13] = (l
>> 8) & 0xff;
1603 digest
[12] = (l
>> 16) & 0xff;
1605 l
= itoa64_to_int (buf
[20]) << 0;
1606 l
|= itoa64_to_int (buf
[21]) << 6;
1607 l
|= itoa64_to_int (buf
[22]) << 12;
1608 l
|= itoa64_to_int (buf
[23]) << 18;
1610 digest
[17] = (l
>> 0) & 0xff;
1611 digest
[16] = (l
>> 8) & 0xff;
1612 digest
[15] = (l
>> 16) & 0xff;
1614 l
= itoa64_to_int (buf
[24]) << 0;
1615 l
|= itoa64_to_int (buf
[25]) << 6;
1616 l
|= itoa64_to_int (buf
[26]) << 12;
1617 l
|= itoa64_to_int (buf
[27]) << 18;
1619 digest
[20] = (l
>> 0) & 0xff;
1620 digest
[19] = (l
>> 8) & 0xff;
1621 digest
[18] = (l
>> 16) & 0xff;
1623 l
= itoa64_to_int (buf
[28]) << 0;
1624 l
|= itoa64_to_int (buf
[29]) << 6;
1625 l
|= itoa64_to_int (buf
[30]) << 12;
1626 l
|= itoa64_to_int (buf
[31]) << 18;
1628 digest
[23] = (l
>> 0) & 0xff;
1629 digest
[22] = (l
>> 8) & 0xff;
1630 digest
[21] = (l
>> 16) & 0xff;
1632 l
= itoa64_to_int (buf
[32]) << 0;
1633 l
|= itoa64_to_int (buf
[33]) << 6;
1634 l
|= itoa64_to_int (buf
[34]) << 12;
1635 l
|= itoa64_to_int (buf
[35]) << 18;
1637 digest
[26] = (l
>> 0) & 0xff;
1638 digest
[25] = (l
>> 8) & 0xff;
1639 digest
[24] = (l
>> 16) & 0xff;
1641 l
= itoa64_to_int (buf
[36]) << 0;
1642 l
|= itoa64_to_int (buf
[37]) << 6;
1643 l
|= itoa64_to_int (buf
[38]) << 12;
1644 l
|= itoa64_to_int (buf
[39]) << 18;
1646 digest
[29] = (l
>> 0) & 0xff;
1647 digest
[28] = (l
>> 8) & 0xff;
1648 digest
[27] = (l
>> 16) & 0xff;
1650 l
= itoa64_to_int (buf
[40]) << 0;
1651 l
|= itoa64_to_int (buf
[41]) << 6;
1652 l
|= itoa64_to_int (buf
[42]) << 12;
1653 l
|= itoa64_to_int (buf
[43]) << 18;
1655 digest
[32] = (l
>> 0) & 0xff;
1656 digest
[31] = (l
>> 8) & 0xff;
1657 digest
[30] = (l
>> 16) & 0xff;
1659 l
= itoa64_to_int (buf
[44]) << 0;
1660 l
|= itoa64_to_int (buf
[45]) << 6;
1661 l
|= itoa64_to_int (buf
[46]) << 12;
1662 l
|= itoa64_to_int (buf
[47]) << 18;
1664 digest
[35] = (l
>> 0) & 0xff;
1665 digest
[34] = (l
>> 8) & 0xff;
1666 digest
[33] = (l
>> 16) & 0xff;
1668 l
= itoa64_to_int (buf
[48]) << 0;
1669 l
|= itoa64_to_int (buf
[49]) << 6;
1670 l
|= itoa64_to_int (buf
[50]) << 12;
1671 l
|= itoa64_to_int (buf
[51]) << 18;
1673 digest
[38] = (l
>> 0) & 0xff;
1674 digest
[37] = (l
>> 8) & 0xff;
1675 digest
[36] = (l
>> 16) & 0xff;
1677 l
= itoa64_to_int (buf
[52]) << 0;
1678 l
|= itoa64_to_int (buf
[53]) << 6;
1679 l
|= itoa64_to_int (buf
[54]) << 12;
1680 l
|= itoa64_to_int (buf
[55]) << 18;
1682 digest
[41] = (l
>> 0) & 0xff;
1683 digest
[40] = (l
>> 8) & 0xff;
1684 digest
[39] = (l
>> 16) & 0xff;
1686 l
= itoa64_to_int (buf
[56]) << 0;
1687 l
|= itoa64_to_int (buf
[57]) << 6;
1688 l
|= itoa64_to_int (buf
[58]) << 12;
1689 l
|= itoa64_to_int (buf
[59]) << 18;
1691 digest
[44] = (l
>> 0) & 0xff;
1692 digest
[43] = (l
>> 8) & 0xff;
1693 digest
[42] = (l
>> 16) & 0xff;
1695 l
= itoa64_to_int (buf
[60]) << 0;
1696 l
|= itoa64_to_int (buf
[61]) << 6;
1697 l
|= itoa64_to_int (buf
[62]) << 12;
1698 l
|= itoa64_to_int (buf
[63]) << 18;
1700 digest
[47] = (l
>> 0) & 0xff;
1701 digest
[46] = (l
>> 8) & 0xff;
1702 digest
[45] = (l
>> 16) & 0xff;
1704 l
= itoa64_to_int (buf
[64]) << 0;
1705 l
|= itoa64_to_int (buf
[65]) << 6;
1706 l
|= itoa64_to_int (buf
[66]) << 12;
1707 l
|= itoa64_to_int (buf
[67]) << 18;
1709 digest
[50] = (l
>> 0) & 0xff;
1710 digest
[49] = (l
>> 8) & 0xff;
1711 digest
[48] = (l
>> 16) & 0xff;
1713 l
= itoa64_to_int (buf
[68]) << 0;
1714 l
|= itoa64_to_int (buf
[69]) << 6;
1715 l
|= itoa64_to_int (buf
[70]) << 12;
1716 l
|= itoa64_to_int (buf
[71]) << 18;
1718 digest
[53] = (l
>> 0) & 0xff;
1719 digest
[52] = (l
>> 8) & 0xff;
1720 digest
[51] = (l
>> 16) & 0xff;
1722 l
= itoa64_to_int (buf
[72]) << 0;
1723 l
|= itoa64_to_int (buf
[73]) << 6;
1724 l
|= itoa64_to_int (buf
[74]) << 12;
1725 l
|= itoa64_to_int (buf
[75]) << 18;
1727 digest
[56] = (l
>> 0) & 0xff;
1728 digest
[55] = (l
>> 8) & 0xff;
1729 digest
[54] = (l
>> 16) & 0xff;
1731 l
= itoa64_to_int (buf
[76]) << 0;
1732 l
|= itoa64_to_int (buf
[77]) << 6;
1733 l
|= itoa64_to_int (buf
[78]) << 12;
1734 l
|= itoa64_to_int (buf
[79]) << 18;
1736 digest
[59] = (l
>> 0) & 0xff;
1737 digest
[58] = (l
>> 8) & 0xff;
1738 digest
[57] = (l
>> 16) & 0xff;
1740 l
= itoa64_to_int (buf
[80]) << 0;
1741 l
|= itoa64_to_int (buf
[81]) << 6;
1742 l
|= itoa64_to_int (buf
[82]) << 12;
1743 l
|= itoa64_to_int (buf
[83]) << 18;
1745 digest
[62] = (l
>> 0) & 0xff;
1746 digest
[61] = (l
>> 8) & 0xff;
1747 digest
[60] = (l
>> 16) & 0xff;
1749 l
= itoa64_to_int (buf
[84]) << 0;
1750 l
|= itoa64_to_int (buf
[85]) << 6;
1752 digest
[63] = (l
>> 16) & 0xff;
1755 void sha512aix_encode (unsigned char digest
[64], unsigned char buf
[86])
1759 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1761 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1762 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1763 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1764 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1766 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1768 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1770 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1771 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1773 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1775 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1777 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1778 buf
[11] = int_to_itoa64 (l
& 0x3f);
1780 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1782 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1784 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1785 buf
[15] = int_to_itoa64 (l
& 0x3f);
1787 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1789 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1791 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1792 buf
[19] = int_to_itoa64 (l
& 0x3f);
1794 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1796 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1798 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1799 buf
[23] = int_to_itoa64 (l
& 0x3f);
1801 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1803 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1805 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1806 buf
[27] = int_to_itoa64 (l
& 0x3f);
1808 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1810 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1812 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1813 buf
[31] = int_to_itoa64 (l
& 0x3f);
1815 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1817 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1819 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1820 buf
[35] = int_to_itoa64 (l
& 0x3f);
1822 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1824 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1826 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1827 buf
[39] = int_to_itoa64 (l
& 0x3f);
1829 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1831 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1833 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1834 buf
[43] = int_to_itoa64 (l
& 0x3f);
1836 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1838 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1840 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1841 buf
[47] = int_to_itoa64 (l
& 0x3f);
1843 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1845 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1847 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1848 buf
[51] = int_to_itoa64 (l
& 0x3f);
1850 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1852 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1854 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1855 buf
[55] = int_to_itoa64 (l
& 0x3f);
1857 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1859 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1861 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1862 buf
[59] = int_to_itoa64 (l
& 0x3f);
1864 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1866 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1868 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1869 buf
[63] = int_to_itoa64 (l
& 0x3f);
1871 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1873 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1875 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1876 buf
[67] = int_to_itoa64 (l
& 0x3f);
1878 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1880 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1882 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1883 buf
[71] = int_to_itoa64 (l
& 0x3f);
1885 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1887 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1889 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1890 buf
[75] = int_to_itoa64 (l
& 0x3f);
1892 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1894 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1896 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1897 buf
[79] = int_to_itoa64 (l
& 0x3f);
1899 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1901 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1903 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1904 buf
[83] = int_to_itoa64 (l
& 0x3f);
1906 l
= 0 | 0 | (digest
[63] << 16);
1908 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1912 void sha256crypt_decode (unsigned char digest
[32], unsigned char buf
[43])
1916 l
= itoa64_to_int (buf
[ 0]) << 0;
1917 l
|= itoa64_to_int (buf
[ 1]) << 6;
1918 l
|= itoa64_to_int (buf
[ 2]) << 12;
1919 l
|= itoa64_to_int (buf
[ 3]) << 18;
1921 digest
[ 0] = (l
>> 16) & 0xff;
1922 digest
[10] = (l
>> 8) & 0xff;
1923 digest
[20] = (l
>> 0) & 0xff;
1925 l
= itoa64_to_int (buf
[ 4]) << 0;
1926 l
|= itoa64_to_int (buf
[ 5]) << 6;
1927 l
|= itoa64_to_int (buf
[ 6]) << 12;
1928 l
|= itoa64_to_int (buf
[ 7]) << 18;
1930 digest
[21] = (l
>> 16) & 0xff;
1931 digest
[ 1] = (l
>> 8) & 0xff;
1932 digest
[11] = (l
>> 0) & 0xff;
1934 l
= itoa64_to_int (buf
[ 8]) << 0;
1935 l
|= itoa64_to_int (buf
[ 9]) << 6;
1936 l
|= itoa64_to_int (buf
[10]) << 12;
1937 l
|= itoa64_to_int (buf
[11]) << 18;
1939 digest
[12] = (l
>> 16) & 0xff;
1940 digest
[22] = (l
>> 8) & 0xff;
1941 digest
[ 2] = (l
>> 0) & 0xff;
1943 l
= itoa64_to_int (buf
[12]) << 0;
1944 l
|= itoa64_to_int (buf
[13]) << 6;
1945 l
|= itoa64_to_int (buf
[14]) << 12;
1946 l
|= itoa64_to_int (buf
[15]) << 18;
1948 digest
[ 3] = (l
>> 16) & 0xff;
1949 digest
[13] = (l
>> 8) & 0xff;
1950 digest
[23] = (l
>> 0) & 0xff;
1952 l
= itoa64_to_int (buf
[16]) << 0;
1953 l
|= itoa64_to_int (buf
[17]) << 6;
1954 l
|= itoa64_to_int (buf
[18]) << 12;
1955 l
|= itoa64_to_int (buf
[19]) << 18;
1957 digest
[24] = (l
>> 16) & 0xff;
1958 digest
[ 4] = (l
>> 8) & 0xff;
1959 digest
[14] = (l
>> 0) & 0xff;
1961 l
= itoa64_to_int (buf
[20]) << 0;
1962 l
|= itoa64_to_int (buf
[21]) << 6;
1963 l
|= itoa64_to_int (buf
[22]) << 12;
1964 l
|= itoa64_to_int (buf
[23]) << 18;
1966 digest
[15] = (l
>> 16) & 0xff;
1967 digest
[25] = (l
>> 8) & 0xff;
1968 digest
[ 5] = (l
>> 0) & 0xff;
1970 l
= itoa64_to_int (buf
[24]) << 0;
1971 l
|= itoa64_to_int (buf
[25]) << 6;
1972 l
|= itoa64_to_int (buf
[26]) << 12;
1973 l
|= itoa64_to_int (buf
[27]) << 18;
1975 digest
[ 6] = (l
>> 16) & 0xff;
1976 digest
[16] = (l
>> 8) & 0xff;
1977 digest
[26] = (l
>> 0) & 0xff;
1979 l
= itoa64_to_int (buf
[28]) << 0;
1980 l
|= itoa64_to_int (buf
[29]) << 6;
1981 l
|= itoa64_to_int (buf
[30]) << 12;
1982 l
|= itoa64_to_int (buf
[31]) << 18;
1984 digest
[27] = (l
>> 16) & 0xff;
1985 digest
[ 7] = (l
>> 8) & 0xff;
1986 digest
[17] = (l
>> 0) & 0xff;
1988 l
= itoa64_to_int (buf
[32]) << 0;
1989 l
|= itoa64_to_int (buf
[33]) << 6;
1990 l
|= itoa64_to_int (buf
[34]) << 12;
1991 l
|= itoa64_to_int (buf
[35]) << 18;
1993 digest
[18] = (l
>> 16) & 0xff;
1994 digest
[28] = (l
>> 8) & 0xff;
1995 digest
[ 8] = (l
>> 0) & 0xff;
1997 l
= itoa64_to_int (buf
[36]) << 0;
1998 l
|= itoa64_to_int (buf
[37]) << 6;
1999 l
|= itoa64_to_int (buf
[38]) << 12;
2000 l
|= itoa64_to_int (buf
[39]) << 18;
2002 digest
[ 9] = (l
>> 16) & 0xff;
2003 digest
[19] = (l
>> 8) & 0xff;
2004 digest
[29] = (l
>> 0) & 0xff;
2006 l
= itoa64_to_int (buf
[40]) << 0;
2007 l
|= itoa64_to_int (buf
[41]) << 6;
2008 l
|= itoa64_to_int (buf
[42]) << 12;
2010 digest
[31] = (l
>> 8) & 0xff;
2011 digest
[30] = (l
>> 0) & 0xff;
2014 void sha256crypt_encode (unsigned char digest
[32], unsigned char buf
[43])
2018 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2020 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2021 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2022 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2023 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2027 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2034 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2041 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2048 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2055 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2062 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2069 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2076 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2083 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2090 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 buf
[42] = int_to_itoa64 (l
& 0x3f);
2095 void drupal7_decode (unsigned char digest
[64], unsigned char buf
[44])
2099 l
= itoa64_to_int (buf
[ 0]) << 0;
2100 l
|= itoa64_to_int (buf
[ 1]) << 6;
2101 l
|= itoa64_to_int (buf
[ 2]) << 12;
2102 l
|= itoa64_to_int (buf
[ 3]) << 18;
2104 digest
[ 0] = (l
>> 0) & 0xff;
2105 digest
[ 1] = (l
>> 8) & 0xff;
2106 digest
[ 2] = (l
>> 16) & 0xff;
2108 l
= itoa64_to_int (buf
[ 4]) << 0;
2109 l
|= itoa64_to_int (buf
[ 5]) << 6;
2110 l
|= itoa64_to_int (buf
[ 6]) << 12;
2111 l
|= itoa64_to_int (buf
[ 7]) << 18;
2113 digest
[ 3] = (l
>> 0) & 0xff;
2114 digest
[ 4] = (l
>> 8) & 0xff;
2115 digest
[ 5] = (l
>> 16) & 0xff;
2117 l
= itoa64_to_int (buf
[ 8]) << 0;
2118 l
|= itoa64_to_int (buf
[ 9]) << 6;
2119 l
|= itoa64_to_int (buf
[10]) << 12;
2120 l
|= itoa64_to_int (buf
[11]) << 18;
2122 digest
[ 6] = (l
>> 0) & 0xff;
2123 digest
[ 7] = (l
>> 8) & 0xff;
2124 digest
[ 8] = (l
>> 16) & 0xff;
2126 l
= itoa64_to_int (buf
[12]) << 0;
2127 l
|= itoa64_to_int (buf
[13]) << 6;
2128 l
|= itoa64_to_int (buf
[14]) << 12;
2129 l
|= itoa64_to_int (buf
[15]) << 18;
2131 digest
[ 9] = (l
>> 0) & 0xff;
2132 digest
[10] = (l
>> 8) & 0xff;
2133 digest
[11] = (l
>> 16) & 0xff;
2135 l
= itoa64_to_int (buf
[16]) << 0;
2136 l
|= itoa64_to_int (buf
[17]) << 6;
2137 l
|= itoa64_to_int (buf
[18]) << 12;
2138 l
|= itoa64_to_int (buf
[19]) << 18;
2140 digest
[12] = (l
>> 0) & 0xff;
2141 digest
[13] = (l
>> 8) & 0xff;
2142 digest
[14] = (l
>> 16) & 0xff;
2144 l
= itoa64_to_int (buf
[20]) << 0;
2145 l
|= itoa64_to_int (buf
[21]) << 6;
2146 l
|= itoa64_to_int (buf
[22]) << 12;
2147 l
|= itoa64_to_int (buf
[23]) << 18;
2149 digest
[15] = (l
>> 0) & 0xff;
2150 digest
[16] = (l
>> 8) & 0xff;
2151 digest
[17] = (l
>> 16) & 0xff;
2153 l
= itoa64_to_int (buf
[24]) << 0;
2154 l
|= itoa64_to_int (buf
[25]) << 6;
2155 l
|= itoa64_to_int (buf
[26]) << 12;
2156 l
|= itoa64_to_int (buf
[27]) << 18;
2158 digest
[18] = (l
>> 0) & 0xff;
2159 digest
[19] = (l
>> 8) & 0xff;
2160 digest
[20] = (l
>> 16) & 0xff;
2162 l
= itoa64_to_int (buf
[28]) << 0;
2163 l
|= itoa64_to_int (buf
[29]) << 6;
2164 l
|= itoa64_to_int (buf
[30]) << 12;
2165 l
|= itoa64_to_int (buf
[31]) << 18;
2167 digest
[21] = (l
>> 0) & 0xff;
2168 digest
[22] = (l
>> 8) & 0xff;
2169 digest
[23] = (l
>> 16) & 0xff;
2171 l
= itoa64_to_int (buf
[32]) << 0;
2172 l
|= itoa64_to_int (buf
[33]) << 6;
2173 l
|= itoa64_to_int (buf
[34]) << 12;
2174 l
|= itoa64_to_int (buf
[35]) << 18;
2176 digest
[24] = (l
>> 0) & 0xff;
2177 digest
[25] = (l
>> 8) & 0xff;
2178 digest
[26] = (l
>> 16) & 0xff;
2180 l
= itoa64_to_int (buf
[36]) << 0;
2181 l
|= itoa64_to_int (buf
[37]) << 6;
2182 l
|= itoa64_to_int (buf
[38]) << 12;
2183 l
|= itoa64_to_int (buf
[39]) << 18;
2185 digest
[27] = (l
>> 0) & 0xff;
2186 digest
[28] = (l
>> 8) & 0xff;
2187 digest
[29] = (l
>> 16) & 0xff;
2189 l
= itoa64_to_int (buf
[40]) << 0;
2190 l
|= itoa64_to_int (buf
[41]) << 6;
2191 l
|= itoa64_to_int (buf
[42]) << 12;
2192 l
|= itoa64_to_int (buf
[43]) << 18;
2194 digest
[30] = (l
>> 0) & 0xff;
2195 digest
[31] = (l
>> 8) & 0xff;
2196 digest
[32] = (l
>> 16) & 0xff;
2231 void drupal7_encode (unsigned char digest
[64], unsigned char buf
[43])
2235 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2237 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2238 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2239 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2240 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2242 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2244 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2246 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2247 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2249 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2251 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2253 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2254 buf
[11] = int_to_itoa64 (l
& 0x3f);
2256 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2258 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2260 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2261 buf
[15] = int_to_itoa64 (l
& 0x3f);
2263 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2265 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2267 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2268 buf
[19] = int_to_itoa64 (l
& 0x3f);
2270 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2272 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2274 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2275 buf
[23] = int_to_itoa64 (l
& 0x3f);
2277 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2279 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2281 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2282 buf
[27] = int_to_itoa64 (l
& 0x3f);
2284 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2286 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2288 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2289 buf
[31] = int_to_itoa64 (l
& 0x3f);
2291 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2293 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2295 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2296 buf
[35] = int_to_itoa64 (l
& 0x3f);
2298 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2300 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2302 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2303 buf
[39] = int_to_itoa64 (l
& 0x3f);
2305 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2307 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2309 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2310 //buf[43] = int_to_itoa64 (l & 0x3f);
2318 static struct termio savemodes
;
2319 static int havemodes
= 0;
2323 struct termio modmodes
;
2325 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2329 modmodes
= savemodes
;
2330 modmodes
.c_lflag
&= ~ICANON
;
2331 modmodes
.c_cc
[VMIN
] = 1;
2332 modmodes
.c_cc
[VTIME
] = 0;
2334 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2343 FD_SET (fileno (stdin
), &rfds
);
2350 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2352 if (retval
== 0) return 0;
2353 if (retval
== -1) return -1;
2360 if (!havemodes
) return 0;
2362 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2367 static struct termios savemodes
;
2368 static int havemodes
= 0;
2372 struct termios modmodes
;
2374 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2378 modmodes
= savemodes
;
2379 modmodes
.c_lflag
&= ~ICANON
;
2380 modmodes
.c_cc
[VMIN
] = 1;
2381 modmodes
.c_cc
[VTIME
] = 0;
2383 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2392 FD_SET (fileno (stdin
), &rfds
);
2399 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2401 if (retval
== 0) return 0;
2402 if (retval
== -1) return -1;
2409 if (!havemodes
) return 0;
2411 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2416 static DWORD saveMode
= 0;
2420 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2422 GetConsoleMode (stdinHandle
, &saveMode
);
2423 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2430 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2432 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2434 if (rc
== WAIT_TIMEOUT
) return 0;
2435 if (rc
== WAIT_ABANDONED
) return -1;
2436 if (rc
== WAIT_FAILED
) return -1;
2438 // The whole ReadConsoleInput () part is a workaround.
2439 // For some unknown reason, maybe a mingw bug, a random signal
2440 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2441 // Then it wants to read with getche () a keyboard input
2442 // which has never been made.
2444 INPUT_RECORD buf
[100];
2448 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2450 FlushConsoleInputBuffer (stdinHandle
);
2452 for (uint i
= 0; i
< num
; i
++)
2454 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2456 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2458 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2460 return KeyEvent
.uChar
.AsciiChar
;
2468 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2470 SetConsoleMode (stdinHandle
, saveMode
);
2480 #define MSG_ENOMEM "Insufficient memory available"
2482 void *mycalloc (size_t nmemb
, size_t size
)
2484 void *p
= calloc (nmemb
, size
);
2488 log_error ("ERROR: %s", MSG_ENOMEM
);
2496 void *mymalloc (size_t size
)
2498 void *p
= malloc (size
);
2502 log_error ("ERROR: %s", MSG_ENOMEM
);
2507 memset (p
, 0, size
);
2512 void myfree (void *ptr
)
2514 if (ptr
== NULL
) return;
2519 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2521 void *p
= realloc (ptr
, oldsz
+ add
);
2525 log_error ("ERROR: %s", MSG_ENOMEM
);
2530 memset ((char *) p
+ oldsz
, 0, add
);
2535 char *mystrdup (const char *s
)
2537 const size_t len
= strlen (s
);
2539 char *b
= (char *) mymalloc (len
+ 1);
2546 FILE *logfile_open (char *logfile
)
2548 FILE *fp
= fopen (logfile
, "ab");
2558 void logfile_close (FILE *fp
)
2560 if (fp
== stdout
) return;
2565 void logfile_append (const char *fmt
, ...)
2567 if (data
.logfile_disable
== 1) return;
2569 FILE *fp
= logfile_open (data
.logfile
);
2575 vfprintf (fp
, fmt
, ap
);
2586 int logfile_generate_id ()
2588 const int n
= rand ();
2597 char *logfile_generate_topid ()
2599 const int id
= logfile_generate_id ();
2601 char *topid
= (char *) mymalloc (1 + 16 + 1);
2603 sprintf (topid
, "TOP%08x", id
);
2608 char *logfile_generate_subid ()
2610 const int id
= logfile_generate_id ();
2612 char *subid
= (char *) mymalloc (1 + 16 + 1);
2614 sprintf (subid
, "SUB%08x", id
);
2626 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2628 FlushFileBuffers (h
);
2637 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2641 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2645 log_info ("WARN: No NvAPI adapters found");
2655 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2659 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2661 if (hc_NVML_nvmlDeviceGetHandleByIndex (data
.hm_dll
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2663 //can be used to determine if the device by index matches the cuda device by index
2664 //char name[100]; memset (name, 0, sizeof (name));
2665 //hc_NVML_nvmlDeviceGetName (data.hm_dll, nvGPUHandle[i], name, sizeof (name) - 1);
2672 log_info ("WARN: No NVML adapters found");
2681 void hm_close (HM_LIB hm_dll
)
2687 FreeLibrary (hm_dll
);
2694 HM_LIB hm_dll
= NULL
;
2696 if (data
.vendor_id
== VENDOR_ID_AMD
)
2699 hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2702 hm_dll
= LoadLibrary ("atiadlxx.dll");
2706 hm_dll
= LoadLibrary ("atiadlxy.dll");
2713 if (data
.vendor_id
== VENDOR_ID_NV
)
2715 hm_dll
= dlopen ("libnvidia-ml.so", RTLD_LAZY
| RTLD_GLOBAL
);
2722 int get_adapters_num_amd (HM_LIB hm_dll
, int *iNumberAdapters
)
2724 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll
, iNumberAdapters
) != ADL_OK
) return -1;
2726 if (iNumberAdapters
== 0)
2728 log_info ("WARN: No ADL adapters found.");
2737 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2739 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2740 ADLODParameters lpOdParameters;
2742 lpOdParameters.iSize = sizeof (ADLODParameters);
2743 size_t plevels_size = 0;
2745 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2747 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2748 __func__, iAdapterIndex,
2749 lpOdParameters.iNumberOfPerformanceLevels,
2750 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2751 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2753 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2755 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2757 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2759 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2761 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2762 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2763 __func__, iAdapterIndex, j,
2764 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2766 myfree (lpOdPerformanceLevels);
2772 LPAdapterInfo
hm_get_adapter_info_amd (HM_LIB hm_dll
, int iNumberAdapters
)
2774 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2776 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2778 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2780 return lpAdapterInfo
;
2785 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2788 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2792 for (uint i = 0; i < num_adl_adapters; i++)
2794 int opencl_bus_num = hm_device[i].busid;
2795 int opencl_dev_num = hm_device[i].devid;
2797 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2805 if (idx >= DEVICES_MAX) return -1;
2810 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2812 for (uint i = 0; i < opencl_num_devices; i++)
2814 cl_device_topology_amd device_topology;
2816 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2818 hm_device[i].busid = device_topology.pcie.bus;
2819 hm_device[i].devid = device_topology.pcie.device;
2824 void hm_sort_adl_adapters_by_busid_devid (uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2826 // basically bubble sort
2828 for (int i
= 0; i
< num_adl_adapters
; i
++)
2830 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2832 // get info of adapter [x]
2834 uint32_t adapter_index_x
= valid_adl_device_list
[j
];
2835 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2837 uint32_t bus_num_x
= info_x
.iBusNumber
;
2838 uint32_t dev_num_x
= info_x
.iDeviceNumber
;
2840 // get info of adapter [y]
2842 uint32_t adapter_index_y
= valid_adl_device_list
[j
+ 1];
2843 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2845 uint32_t bus_num_y
= info_y
.iBusNumber
;
2846 uint32_t dev_num_y
= info_y
.iDeviceNumber
;
2850 if (bus_num_y
< bus_num_x
)
2854 else if (bus_num_y
== bus_num_x
)
2856 if (dev_num_y
< dev_num_x
)
2864 uint32_t temp
= valid_adl_device_list
[j
+ 1];
2866 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2867 valid_adl_device_list
[j
+ 0] = temp
;
2873 uint32_t *hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2875 *num_adl_adapters
= 0;
2877 uint32_t *adl_adapters
= NULL
;
2879 int *bus_numbers
= NULL
;
2880 int *device_numbers
= NULL
;
2882 for (int i
= 0; i
< iNumberAdapters
; i
++)
2884 AdapterInfo info
= lpAdapterInfo
[i
];
2886 if ((info
.strUDID
== NULL
) || (strlen (info
.strUDID
) < 1)) continue;
2889 if (info
.iVendorID
!= 1002) continue;
2891 if (info
.iVendorID
!= 0x1002) continue;
2894 if (info
.iBusNumber
< 0) continue;
2895 if (info
.iDeviceNumber
< 0) continue;
2899 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2901 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2908 if (found
) continue;
2910 // add it to the list
2912 adl_adapters
= (uint32_t *) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2914 adl_adapters
[*num_adl_adapters
] = i
;
2916 // rest is just bookkeeping
2918 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2919 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2921 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2922 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2924 (*num_adl_adapters
)++;
2927 myfree (bus_numbers
);
2928 myfree (device_numbers
);
2930 // sort the list by increasing bus id, device id number
2932 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2934 return adl_adapters
;
2937 int hm_check_fanspeed_control (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2939 // loop through all valid devices
2941 for (int i
= 0; i
< num_adl_adapters
; i
++)
2943 uint32_t adapter_index
= valid_adl_device_list
[i
];
2947 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2949 // unfortunately this doesn't work since bus id and dev id are not unique
2950 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2951 // if (opencl_device_index == -1) continue;
2953 int opencl_device_index
= i
;
2955 // if (hm_show_performance_level (hm_dll, info.iAdapterIndex) != 0) return -1;
2957 // get fanspeed info
2959 if (hm_device
[opencl_device_index
].od_version
== 5)
2961 ADLFanSpeedInfo FanSpeedInfo
;
2963 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2965 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2967 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2969 // check read and write capability in fanspeedinfo
2971 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2972 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2974 hm_device
[opencl_device_index
].fan_supported
= 1;
2978 hm_device
[opencl_device_index
].fan_supported
= 0;
2981 else // od_version == 6
2983 ADLOD6FanSpeedInfo faninfo
;
2985 memset (&faninfo
, 0, sizeof (faninfo
));
2987 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2989 // check read capability in fanspeedinfo
2991 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2993 hm_device
[opencl_device_index
].fan_supported
= 1;
2997 hm_device
[opencl_device_index
].fan_supported
= 0;
3005 int hm_get_overdrive_version (HM_LIB hm_dll
, hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3007 for (int i
= 0; i
< num_adl_adapters
; i
++)
3009 uint32_t adapter_index
= valid_adl_device_list
[i
];
3013 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3015 // get overdrive version
3017 int od_supported
= 0;
3021 if (hc_ADL_Overdrive_Caps (hm_dll
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3023 // store the overdrive version in hm_device
3025 // unfortunately this doesn't work since bus id and dev id are not unique
3026 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3027 // if (opencl_device_index == -1) continue;
3029 int opencl_device_index
= i
;
3031 hm_device
[opencl_device_index
].od_version
= od_version
;
3037 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3039 for (int i
= 0; i
< num_adl_adapters
; i
++)
3041 uint32_t adapter_index
= valid_adl_device_list
[i
];
3045 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3047 // store the iAdapterIndex in hm_device
3049 // unfortunately this doesn't work since bus id and dev id are not unique
3050 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3051 // if (opencl_device_index == -1) continue;
3053 int opencl_device_index
= i
;
3055 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3058 return num_adl_adapters
;
3061 int hm_get_temperature_with_device_id (const uint device_id
)
3063 if (data
.vendor_id
== VENDOR_ID_AMD
)
3067 if (data
.hm_device
[device_id
].od_version
== 5)
3069 ADLTemperature Temperature
;
3071 Temperature
.iSize
= sizeof (ADLTemperature
);
3073 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3075 return Temperature
.iTemperature
/ 1000;
3077 else if (data
.hm_device
[device_id
].od_version
== 6)
3079 int Temperature
= 0;
3081 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3083 return Temperature
/ 1000;
3088 if (data
.vendor_id
== VENDOR_ID_NV
)
3091 int temperature
= 0;
3093 hc_NVML_nvmlDeviceGetTemperature (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3099 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3101 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3102 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3103 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3104 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3106 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3108 return pThermalSettings
.sensor
[0].currentTemp
;
3115 int hm_get_fanspeed_with_device_id (const uint device_id
)
3117 if (data
.hm_device
[device_id
].fan_supported
== 1)
3119 if (data
.vendor_id
== VENDOR_ID_AMD
)
3123 if (data
.hm_device
[device_id
].od_version
== 5)
3125 ADLFanSpeedValue lpFanSpeedValue
;
3127 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3129 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3130 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3131 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3133 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3135 return lpFanSpeedValue
.iFanSpeed
;
3137 else // od_version == 6
3139 ADLOD6FanSpeedInfo faninfo
;
3141 memset (&faninfo
, 0, sizeof (faninfo
));
3143 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3145 return faninfo
.iFanSpeedPercent
;
3150 if (data
.vendor_id
== VENDOR_ID_NV
)
3155 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_dll
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (unsigned int *) &speed
);
3163 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
.nv
, &speed
);
3173 int hm_get_utilization_with_device_id (const uint device_id
)
3175 if (data
.vendor_id
== VENDOR_ID_AMD
)
3179 ADLPMActivity PMActivity
;
3181 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3183 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3185 return PMActivity
.iActivityPercent
;
3189 if (data
.vendor_id
== VENDOR_ID_NV
)
3192 nvmlUtilization_t utilization
;
3194 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3196 return utilization
.gpu
;
3200 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3202 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3204 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3206 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3213 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3215 if (data
.hm_device
[device_id
].fan_supported
== 1)
3219 if (data
.hm_device
[device_id
].od_version
== 5)
3221 ADLFanSpeedValue lpFanSpeedValue
;
3223 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3225 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3226 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3227 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3228 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3230 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3234 else // od_version == 6
3236 ADLOD6FanSpeedValue fan_speed_value
;
3238 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3240 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3241 fan_speed_value
.iFanSpeed
= fanspeed
;
3243 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3257 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3259 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3261 if (css_cnt
> SP_PW_MAX
)
3263 log_error ("ERROR: mask length is too long");
3268 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3270 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3272 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3273 uint cs_len
= css
[css_pos
].cs_len
;
3275 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3277 uint c
= cs_buf
[cs_pos
] & 0xff;
3284 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3286 cs_t
*cs
= &css
[css_cnt
];
3288 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3290 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3292 memset (css_uniq
, 0, css_uniq_sz
);
3296 for (i
= 0; i
< cs
->cs_len
; i
++)
3298 const uint u
= cs
->cs_buf
[i
];
3303 for (i
= 0; i
< in_len
; i
++)
3305 uint u
= in_buf
[i
] & 0xff;
3307 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3309 if (css_uniq
[u
] == 1) continue;
3313 cs
->cs_buf
[cs
->cs_len
] = u
;
3321 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3325 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3327 uint p0
= in_buf
[in_pos
] & 0xff;
3329 if (interpret
== 1 && p0
== '?')
3333 if (in_pos
== in_len
) break;
3335 uint p1
= in_buf
[in_pos
] & 0xff;
3339 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3341 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3343 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3345 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3347 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3349 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3351 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3352 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3354 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3355 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3357 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3358 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3360 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3361 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3363 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3365 default: log_error ("Syntax error: %s", in_buf
);
3371 if (data
.hex_charset
)
3375 if (in_pos
== in_len
)
3377 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3382 uint p1
= in_buf
[in_pos
] & 0xff;
3384 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3386 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3393 chr
= hex_convert (p1
) << 0;
3394 chr
|= hex_convert (p0
) << 4;
3396 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3402 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3408 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3412 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3414 sum
*= css
[css_pos
].cs_len
;
3420 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3422 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3427 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3429 char p0
= mask_buf
[mask_pos
];
3435 if (mask_pos
== mask_len
) break;
3437 char p1
= mask_buf
[mask_pos
];
3443 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3445 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3447 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3449 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3451 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3453 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3455 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3456 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3458 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3459 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3461 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3462 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3464 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3465 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3467 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3469 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3475 if (data
.hex_charset
)
3479 // if there is no 2nd hex character, show an error:
3481 if (mask_pos
== mask_len
)
3483 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3488 char p1
= mask_buf
[mask_pos
];
3490 // if they are not valid hex character, show an error:
3492 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3494 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3501 chr
|= hex_convert (p1
) << 0;
3502 chr
|= hex_convert (p0
) << 4;
3504 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3510 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3517 log_error ("ERROR: invalid mask length (0)");
3527 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3529 for (int i
= 0; i
< css_cnt
; i
++)
3531 uint len
= css
[i
].cs_len
;
3532 uint64_t next
= val
/ len
;
3533 uint pos
= val
% len
;
3534 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3539 void mp_cut_at (char *mask
, uint max
)
3543 uint mask_len
= strlen (mask
);
3545 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3547 if (mask
[i
] == '?') i
++;
3553 void mp_setup_sys (cs_t
*mp_sys
)
3557 uint donec
[CHARSIZ
];
3559 memset (donec
, 0, sizeof (donec
));
3561 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3562 mp_sys
[0].cs_buf
[pos
++] = chr
;
3563 mp_sys
[0].cs_len
= pos
; }
3565 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3566 mp_sys
[1].cs_buf
[pos
++] = chr
;
3567 mp_sys
[1].cs_len
= pos
; }
3569 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3570 mp_sys
[2].cs_buf
[pos
++] = chr
;
3571 mp_sys
[2].cs_len
= pos
; }
3573 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3574 mp_sys
[3].cs_buf
[pos
++] = chr
;
3575 mp_sys
[3].cs_len
= pos
; }
3577 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3578 mp_sys
[4].cs_len
= pos
; }
3580 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3581 mp_sys
[5].cs_len
= pos
; }
3584 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3586 FILE *fp
= fopen (buf
, "rb");
3588 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3590 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3596 memset (mp_file
, 0, sizeof (mp_file
));
3598 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3602 len
= in_superchop (mp_file
);
3606 log_info ("WARNING: charset file corrupted");
3608 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3612 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3617 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3619 mp_usr
[index
].cs_len
= 0;
3621 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3624 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3626 char *new_mask_buf
= (char *) mymalloc (256);
3632 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3634 if (css_pos
== len
) break;
3636 char p0
= mask_buf
[mask_pos
];
3638 new_mask_buf
[mask_pos
] = p0
;
3644 if (mask_pos
== mask_len
) break;
3646 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3650 if (data
.hex_charset
)
3654 if (mask_pos
== mask_len
)
3656 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3661 char p1
= mask_buf
[mask_pos
];
3663 // if they are not valid hex character, show an error:
3665 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3667 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3672 new_mask_buf
[mask_pos
] = p1
;
3677 if (css_pos
== len
) return (new_mask_buf
);
3679 myfree (new_mask_buf
);
3688 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3694 for (i
= start
; i
< stop
; i
++)
3696 sum
*= root_css_buf
[i
].cs_len
;
3702 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3706 cs_t
*cs
= &root_css_buf
[start
];
3710 for (i
= start
; i
< stop
; i
++)
3712 const uint64_t m
= v
% cs
->cs_len
;
3713 const uint64_t d
= v
/ cs
->cs_len
;
3717 const uint k
= cs
->cs_buf
[m
];
3719 pw_buf
[i
- start
] = (char) k
;
3721 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3725 int sp_comp_val (const void *p1
, const void *p2
)
3727 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3728 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3730 return b2
->val
- b1
->val
;
3733 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3740 * Initialize hcstats
3743 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3745 uint64_t *root_stats_ptr
= root_stats_buf
;
3747 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3749 for (i
= 0; i
< SP_PW_MAX
; i
++)
3751 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3753 root_stats_ptr
+= CHARSIZ
;
3756 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3758 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3760 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3762 for (i
= 0; i
< SP_PW_MAX
; i
++)
3764 for (j
= 0; j
< CHARSIZ
; j
++)
3766 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3768 markov_stats_ptr
+= CHARSIZ
;
3778 char hcstat_tmp
[256];
3780 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3782 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3784 hcstat
= hcstat_tmp
;
3787 FILE *fd
= fopen (hcstat
, "rb");
3791 log_error ("%s: %s", hcstat
, strerror (errno
));
3796 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3798 log_error ("%s: Could not load data", hcstat
);
3803 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3805 log_error ("%s: Could not load data", hcstat
);
3813 * Markov modifier of hcstat_table on user request
3818 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3819 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3824 /* Add all stats to first position */
3826 for (i
= 1; i
< SP_PW_MAX
; i
++)
3828 uint64_t *out
= root_stats_buf_by_pos
[0];
3829 uint64_t *in
= root_stats_buf_by_pos
[i
];
3831 for (j
= 0; j
< CHARSIZ
; j
++)
3837 for (i
= 1; i
< SP_PW_MAX
; i
++)
3839 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3840 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3842 for (j
= 0; j
< CHARSIZ
; j
++)
3844 for (k
= 0; k
< CHARSIZ
; k
++)
3851 /* copy them to all pw_positions */
3853 for (i
= 1; i
< SP_PW_MAX
; i
++)
3855 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3858 for (i
= 1; i
< SP_PW_MAX
; i
++)
3860 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3868 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3870 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3872 for (i
= 0; i
< SP_PW_MAX
; i
++)
3874 root_table_buf_by_pos
[i
] = root_table_ptr
;
3876 root_table_ptr
+= CHARSIZ
;
3879 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3881 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3883 for (i
= 0; i
< SP_PW_MAX
; i
++)
3885 for (j
= 0; j
< CHARSIZ
; j
++)
3887 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3889 markov_table_ptr
+= CHARSIZ
;
3894 * Convert hcstat to tables
3897 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3899 uint key
= i
% CHARSIZ
;
3901 root_table_buf
[i
].key
= key
;
3902 root_table_buf
[i
].val
= root_stats_buf
[i
];
3905 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3907 uint key
= i
% CHARSIZ
;
3909 markov_table_buf
[i
].key
= key
;
3910 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3913 myfree (root_stats_buf
);
3914 myfree (markov_stats_buf
);
3920 for (i
= 0; i
< SP_PW_MAX
; i
++)
3922 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3925 for (i
= 0; i
< SP_PW_MAX
; i
++)
3927 for (j
= 0; j
< CHARSIZ
; j
++)
3929 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3934 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3937 * Convert tables to css
3940 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3942 uint pw_pos
= i
/ CHARSIZ
;
3944 cs_t
*cs
= &root_css_buf
[pw_pos
];
3946 if (cs
->cs_len
== threshold
) continue;
3948 uint key
= root_table_buf
[i
].key
;
3950 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3952 cs
->cs_buf
[cs
->cs_len
] = key
;
3958 * Convert table to css
3961 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3963 uint c
= i
/ CHARSIZ
;
3965 cs_t
*cs
= &markov_css_buf
[c
];
3967 if (cs
->cs_len
== threshold
) continue;
3969 uint pw_pos
= c
/ CHARSIZ
;
3971 uint key
= markov_table_buf
[i
].key
;
3973 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3975 cs
->cs_buf
[cs
->cs_len
] = key
;
3981 for (uint i = 0; i < 8; i++)
3983 for (uint j = 0x20; j < 0x80; j++)
3985 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
3987 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
3989 for (uint k = 0; k < 10; k++)
3991 printf (" %u\n", ptr->cs_buf[k]);
3998 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4000 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4002 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4012 for (uint j
= 1; j
< CHARSIZ
; j
++)
4022 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4024 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4026 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4028 out
+= CHARSIZ
* CHARSIZ
;
4029 in
+= CHARSIZ
* CHARSIZ
;
4031 for (uint j
= 0; j
< CHARSIZ
; j
++)
4038 for (uint k
= 1; k
< CHARSIZ
; k
++)
4050 * mixed shared functions
4053 void dump_hex (const char *s
, size_t size
)
4057 for (i
= 0; i
< size
; i
++)
4059 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4065 void usage_mini_print (const char *progname
)
4067 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4070 void usage_big_print (const char *progname
)
4072 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4075 char *get_exec_path ()
4077 int exec_path_len
= 1024;
4079 char *exec_path
= (char *) mymalloc (exec_path_len
);
4085 sprintf (tmp
, "/proc/%d/exe", getpid ());
4087 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4093 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4102 char *get_install_dir (const char *progname
)
4104 char *install_dir
= mystrdup (progname
);
4105 char *last_slash
= NULL
;
4107 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4111 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4117 install_dir
[0] = '.';
4121 return (install_dir
);
4124 char *get_profile_dir (const char *homedir
)
4126 #define DOT_HASHCAT ".hashcat"
4128 char *profile_dir
= (char *) mymalloc (strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1);
4130 sprintf (profile_dir
, "%s/%s", homedir
, DOT_HASHCAT
);
4135 char *get_session_dir (const char *profile_dir
)
4137 #define SESSIONS_FOLDER "sessions"
4139 char *session_dir
= (char *) mymalloc (strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1);
4141 sprintf (session_dir
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4146 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4150 FILE *fd
= fopen (file
, "rb");
4154 log_error ("%s: %s", file
, strerror (errno
));
4159 #define MAX_KEY_SIZE (1024 * 1024)
4161 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4163 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4167 for (int fpos
= 0; fpos
< nread
; fpos
++)
4169 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4171 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4172 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4173 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4174 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4176 if (kpos
>= 64) kpos
= 0;
4184 void set_cpu_affinity (char *cpu_affinity
)
4187 DWORD_PTR aff_mask
= 0;
4198 char *devices
= strdup (cpu_affinity
);
4200 char *next
= strtok (devices
, ",");
4204 uint cpu_id
= atoi (next
);
4221 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4227 aff_mask
|= 1 << (cpu_id
- 1);
4231 CPU_SET ((cpu_id
- 1), &cpuset
);
4234 } while ((next
= strtok (NULL
, ",")) != NULL
);
4240 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4241 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4245 pthread_t thread
= pthread_self ();
4246 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4250 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4252 char *element
, *end
;
4254 end
= (char *) base
+ nmemb
* size
;
4256 for (element
= (char *) base
; element
< end
; element
+= size
)
4257 if (!compar (element
, key
))
4263 int sort_by_salt (const void *v1
, const void *v2
)
4265 const salt_t
*s1
= (const salt_t
*) v1
;
4266 const salt_t
*s2
= (const salt_t
*) v2
;
4268 const int res1
= s1
->salt_len
- s2
->salt_len
;
4270 if (res1
!= 0) return (res1
);
4272 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4274 if (res2
!= 0) return (res2
);
4282 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4283 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4290 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4291 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4297 int sort_by_salt_buf (const void *v1
, const void *v2
)
4299 const pot_t
*p1
= (const pot_t
*) v1
;
4300 const pot_t
*p2
= (const pot_t
*) v2
;
4302 const hash_t
*h1
= &p1
->hash
;
4303 const hash_t
*h2
= &p2
->hash
;
4305 const salt_t
*s1
= h1
->salt
;
4306 const salt_t
*s2
= h2
->salt
;
4312 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4313 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4319 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4321 const hash_t
*h1
= (const hash_t
*) v1
;
4322 const hash_t
*h2
= (const hash_t
*) v2
;
4324 const salt_t
*s1
= h1
->salt
;
4325 const salt_t
*s2
= h2
->salt
;
4327 // testphase: this should work
4332 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4333 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4336 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4337 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4338 if (s1->salt_len > s2->salt_len) return ( 1);
4339 if (s1->salt_len < s2->salt_len) return (-1);
4341 uint n = s1->salt_len;
4345 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4346 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4353 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4355 const hash_t
*h1
= (const hash_t
*) v1
;
4356 const hash_t
*h2
= (const hash_t
*) v2
;
4358 const salt_t
*s1
= h1
->salt
;
4359 const salt_t
*s2
= h2
->salt
;
4361 // 12 - 2 (since last 2 uints contain the digest)
4366 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4367 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4373 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4375 const hash_t
*h1
= (const hash_t
*) v1
;
4376 const hash_t
*h2
= (const hash_t
*) v2
;
4378 const void *d1
= h1
->digest
;
4379 const void *d2
= h2
->digest
;
4381 return data
.sort_by_digest (d1
, d2
);
4384 int sort_by_hash (const void *v1
, const void *v2
)
4386 const hash_t
*h1
= (const hash_t
*) v1
;
4387 const hash_t
*h2
= (const hash_t
*) v2
;
4391 const salt_t
*s1
= h1
->salt
;
4392 const salt_t
*s2
= h2
->salt
;
4394 int res
= sort_by_salt (s1
, s2
);
4396 if (res
!= 0) return (res
);
4399 const void *d1
= h1
->digest
;
4400 const void *d2
= h2
->digest
;
4402 return data
.sort_by_digest (d1
, d2
);
4405 int sort_by_pot (const void *v1
, const void *v2
)
4407 const pot_t
*p1
= (const pot_t
*) v1
;
4408 const pot_t
*p2
= (const pot_t
*) v2
;
4410 const hash_t
*h1
= &p1
->hash
;
4411 const hash_t
*h2
= &p2
->hash
;
4413 return sort_by_hash (h1
, h2
);
4416 int sort_by_mtime (const void *p1
, const void *p2
)
4418 const char **f1
= (const char **) p1
;
4419 const char **f2
= (const char **) p2
;
4421 struct stat s1
; stat (*f1
, &s1
);
4422 struct stat s2
; stat (*f2
, &s2
);
4424 return s2
.st_mtime
- s1
.st_mtime
;
4427 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4429 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4430 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4432 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4435 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4437 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4438 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4440 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4443 int sort_by_stringptr (const void *p1
, const void *p2
)
4445 const char **s1
= (const char **) p1
;
4446 const char **s2
= (const char **) p2
;
4448 return strcmp (*s1
, *s2
);
4451 int sort_by_dictstat (const void *s1
, const void *s2
)
4453 dictstat_t
*d1
= (dictstat_t
*) s1
;
4454 dictstat_t
*d2
= (dictstat_t
*) s2
;
4457 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4459 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4462 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4465 int sort_by_bitmap (const void *p1
, const void *p2
)
4467 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4468 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4470 return b1
->collisions
- b2
->collisions
;
4473 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4475 const uint32_t *d1
= (const uint32_t *) v1
;
4476 const uint32_t *d2
= (const uint32_t *) v2
;
4482 if (d1
[n
] > d2
[n
]) return ( 1);
4483 if (d1
[n
] < d2
[n
]) return (-1);
4489 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4491 const uint32_t *d1
= (const uint32_t *) v1
;
4492 const uint32_t *d2
= (const uint32_t *) v2
;
4498 if (d1
[n
] > d2
[n
]) return ( 1);
4499 if (d1
[n
] < d2
[n
]) return (-1);
4505 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4507 const uint32_t *d1
= (const uint32_t *) v1
;
4508 const uint32_t *d2
= (const uint32_t *) v2
;
4514 if (d1
[n
] > d2
[n
]) return ( 1);
4515 if (d1
[n
] < d2
[n
]) return (-1);
4521 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4523 const uint32_t *d1
= (const uint32_t *) v1
;
4524 const uint32_t *d2
= (const uint32_t *) v2
;
4530 if (d1
[n
] > d2
[n
]) return ( 1);
4531 if (d1
[n
] < d2
[n
]) return (-1);
4537 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4539 const uint32_t *d1
= (const uint32_t *) v1
;
4540 const uint32_t *d2
= (const uint32_t *) v2
;
4546 if (d1
[n
] > d2
[n
]) return ( 1);
4547 if (d1
[n
] < d2
[n
]) return (-1);
4553 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4555 const uint32_t *d1
= (const uint32_t *) v1
;
4556 const uint32_t *d2
= (const uint32_t *) v2
;
4562 if (d1
[n
] > d2
[n
]) return ( 1);
4563 if (d1
[n
] < d2
[n
]) return (-1);
4569 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4571 const uint32_t *d1
= (const uint32_t *) v1
;
4572 const uint32_t *d2
= (const uint32_t *) v2
;
4578 if (d1
[n
] > d2
[n
]) return ( 1);
4579 if (d1
[n
] < d2
[n
]) return (-1);
4585 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4587 const uint32_t *d1
= (const uint32_t *) v1
;
4588 const uint32_t *d2
= (const uint32_t *) v2
;
4594 if (d1
[n
] > d2
[n
]) return ( 1);
4595 if (d1
[n
] < d2
[n
]) return (-1);
4601 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4603 const uint64_t *d1
= (const uint64_t *) v1
;
4604 const uint64_t *d2
= (const uint64_t *) v2
;
4610 if (d1
[n
] > d2
[n
]) return ( 1);
4611 if (d1
[n
] < d2
[n
]) return (-1);
4617 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4619 const uint64_t *d1
= (const uint64_t *) v1
;
4620 const uint64_t *d2
= (const uint64_t *) v2
;
4626 if (d1
[n
] > d2
[n
]) return ( 1);
4627 if (d1
[n
] < d2
[n
]) return (-1);
4633 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4635 const uint64_t *d1
= (const uint64_t *) v1
;
4636 const uint64_t *d2
= (const uint64_t *) v2
;
4642 if (d1
[n
] > d2
[n
]) return ( 1);
4643 if (d1
[n
] < d2
[n
]) return (-1);
4649 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4651 const uint32_t *d1
= (const uint32_t *) v1
;
4652 const uint32_t *d2
= (const uint32_t *) v2
;
4654 const uint dgst_pos0
= data
.dgst_pos0
;
4655 const uint dgst_pos1
= data
.dgst_pos1
;
4656 const uint dgst_pos2
= data
.dgst_pos2
;
4657 const uint dgst_pos3
= data
.dgst_pos3
;
4659 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4660 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4661 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4662 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4663 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4664 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4665 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4666 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4671 void format_debug (char * debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4673 uint outfile_autohex
= data
.outfile_autohex
;
4675 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4677 FILE *debug_fp
= NULL
;
4679 if (debug_file
!= NULL
)
4681 debug_fp
= fopen (debug_file
, "ab");
4688 if (debug_fp
== NULL
)
4690 log_info ("WARNING: Could not open debug-file for writing");
4694 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4696 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4698 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4701 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4703 if (debug_mode
== 4)
4705 fputc (':', debug_fp
);
4707 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4710 fputc ('\n', debug_fp
);
4712 if (debug_file
!= NULL
) fclose (debug_fp
);
4716 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4718 int needs_hexify
= 0;
4720 if (outfile_autohex
== 1)
4722 for (uint i
= 0; i
< plain_len
; i
++)
4724 if (plain_ptr
[i
] < 0x20)
4731 if (plain_ptr
[i
] > 0x7f)
4740 if (needs_hexify
== 1)
4742 fprintf (fp
, "$HEX[");
4744 for (uint i
= 0; i
< plain_len
; i
++)
4746 fprintf (fp
, "%02x", plain_ptr
[i
]);
4753 fwrite (plain_ptr
, plain_len
, 1, fp
);
4757 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const uint64_t crackpos
, unsigned char *username
, const uint user_len
)
4759 uint outfile_format
= data
.outfile_format
;
4761 char separator
= data
.separator
;
4763 if (outfile_format
& OUTFILE_FMT_HASH
)
4765 fprintf (out_fp
, "%s", out_buf
);
4767 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4769 fputc (separator
, out_fp
);
4772 else if (data
.username
)
4774 if (username
!= NULL
)
4776 for (uint i
= 0; i
< user_len
; i
++)
4778 fprintf (out_fp
, "%c", username
[i
]);
4781 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4783 fputc (separator
, out_fp
);
4788 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4790 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4792 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4794 fputc (separator
, out_fp
);
4798 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4800 for (uint i
= 0; i
< plain_len
; i
++)
4802 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4805 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4807 fputc (separator
, out_fp
);
4811 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4814 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4819 fprintf (out_fp
, "%lu", crackpos
);
4821 fprintf (out_fp
, "%llu", crackpos
);
4826 fputc ('\n', out_fp
);
4829 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4833 pot_key
.hash
.salt
= hashes_buf
->salt
;
4834 pot_key
.hash
.digest
= hashes_buf
->digest
;
4836 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4842 input_buf
[input_len
] = 0;
4845 unsigned char *username
= NULL
;
4850 user_t
*user
= hashes_buf
->hash_info
->user
;
4854 username
= (unsigned char *) (user
->user_name
);
4856 user_len
= user
->user_len
;
4860 // do output the line
4861 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4865 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4866 #define LM_MASKED_PLAIN "[notfound]"
4868 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4874 pot_left_key
.hash
.salt
= hash_left
->salt
;
4875 pot_left_key
.hash
.digest
= hash_left
->digest
;
4877 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4881 uint weak_hash_found
= 0;
4883 pot_t pot_right_key
;
4885 pot_right_key
.hash
.salt
= hash_right
->salt
;
4886 pot_right_key
.hash
.digest
= hash_right
->digest
;
4888 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4890 if (pot_right_ptr
== NULL
)
4892 // special case, if "weak hash"
4894 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4896 weak_hash_found
= 1;
4898 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4900 // in theory this is not needed, but we are paranoia:
4902 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4903 pot_right_ptr
->plain_len
= 0;
4907 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4909 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
4914 // at least one half was found:
4918 input_buf
[input_len
] = 0;
4922 unsigned char *username
= NULL
;
4927 user_t
*user
= hash_left
->hash_info
->user
;
4931 username
= (unsigned char *) (user
->user_name
);
4933 user_len
= user
->user_len
;
4937 // mask the part which was not found
4939 uint left_part_masked
= 0;
4940 uint right_part_masked
= 0;
4942 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4944 if (pot_left_ptr
== NULL
)
4946 left_part_masked
= 1;
4948 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4950 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4952 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4953 pot_left_ptr
->plain_len
= mask_plain_len
;
4956 if (pot_right_ptr
== NULL
)
4958 right_part_masked
= 1;
4960 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4962 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4964 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4965 pot_right_ptr
->plain_len
= mask_plain_len
;
4968 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4972 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4974 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4976 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4978 // do output the line
4980 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4982 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4984 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4985 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4988 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4992 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4994 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4996 if (pot_ptr
== NULL
)
5000 input_buf
[input_len
] = 0;
5002 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5006 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5014 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5018 pot_t pot_right_key
;
5020 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5022 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5024 uint weak_hash_found
= 0;
5026 if (pot_right_ptr
== NULL
)
5028 // special case, if "weak hash"
5030 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5032 weak_hash_found
= 1;
5034 // we just need that pot_right_ptr is not a NULL pointer
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5040 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5042 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5047 // ... at least one part was not cracked
5051 input_buf
[input_len
] = 0;
5053 // only show the hash part which is still not cracked
5055 uint user_len
= input_len
- 32;
5057 char hash_output
[user_len
+ 33];
5059 memset (hash_output
, 0, sizeof (hash_output
));
5061 memcpy (hash_output
, input_buf
, input_len
);
5063 if (pot_left_ptr
!= NULL
)
5065 // only show right part (because left part was already found)
5067 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5069 hash_output
[user_len
+ 16] = 0;
5072 if (pot_right_ptr
!= NULL
)
5074 // only show left part (because right part was already found)
5076 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5078 hash_output
[user_len
+ 16] = 0;
5081 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5083 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5086 uint
devices_to_devicemask (char *opencl_devices
)
5088 uint opencl_devicemask
= 0;
5092 char *devices
= strdup (opencl_devices
);
5094 char *next
= strtok (devices
, ",");
5098 uint device_id
= atoi (next
);
5100 if (device_id
< 1 || device_id
> 8)
5102 log_error ("ERROR: invalid device_id %u specified", device_id
);
5107 opencl_devicemask
|= 1 << (device_id
- 1);
5109 } while ((next
= strtok (NULL
, ",")) != NULL
);
5114 return opencl_devicemask
;
5117 uint
get_random_num (uint min
, uint max
)
5119 if (min
== max
) return (min
);
5121 return (uint
) ((rand () % (max
- min
)) + min
);
5124 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5126 uint32_t quotient
= dividend
/ divisor
;
5128 if (dividend
% divisor
) quotient
++;
5133 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5135 uint64_t quotient
= dividend
/ divisor
;
5137 if (dividend
% divisor
) quotient
++;
5142 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5144 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5145 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5147 if (tm
->tm_year
- 70)
5149 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5150 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5152 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5154 else if (tm
->tm_yday
)
5156 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5157 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5159 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5161 else if (tm
->tm_hour
)
5163 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5164 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5166 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5168 else if (tm
->tm_min
)
5170 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5171 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5173 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5177 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5179 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5183 void format_speed_display (float val
, char *buf
, size_t len
)
5194 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5205 /* generate output */
5209 snprintf (buf
, len
- 1, "%.0f ", val
);
5213 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5217 void lowercase (char *buf
, int len
)
5219 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5222 void uppercase (char *buf
, int len
)
5224 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5227 int fgetl (FILE *fp
, char *line_buf
)
5233 const int c
= fgetc (fp
);
5235 if (c
== EOF
) break;
5237 line_buf
[line_len
] = (char) c
;
5241 if (line_len
== BUFSIZ
) line_len
--;
5243 if (c
== '\n') break;
5246 if (line_len
== 0) return 0;
5248 if (line_buf
[line_len
- 1] == '\n')
5252 line_buf
[line_len
] = 0;
5255 if (line_len
== 0) return 0;
5257 if (line_buf
[line_len
- 1] == '\r')
5261 line_buf
[line_len
] = 0;
5267 int in_superchop (char *buf
)
5269 int len
= strlen (buf
);
5273 if (buf
[len
- 1] == '\n')
5280 if (buf
[len
- 1] == '\r')
5295 char **scan_directory (const char *path
)
5297 char *tmp_path
= mystrdup (path
);
5299 size_t tmp_path_len
= strlen (tmp_path
);
5301 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5303 tmp_path
[tmp_path_len
- 1] = 0;
5305 tmp_path_len
= strlen (tmp_path
);
5308 char **files
= NULL
;
5314 if ((d
= opendir (tmp_path
)) != NULL
)
5318 while ((de
= readdir (d
)) != NULL
)
5320 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5322 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5324 char *path_file
= (char *) mymalloc (path_size
+ 1);
5326 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5328 path_file
[path_size
] = 0;
5332 if ((d_test
= opendir (path_file
)) != NULL
)
5340 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5344 files
[num_files
- 1] = path_file
;
5350 else if (errno
== ENOTDIR
)
5352 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5356 files
[num_files
- 1] = mystrdup (path
);
5359 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5363 files
[num_files
- 1] = NULL
;
5370 int count_dictionaries (char **dictionary_files
)
5372 if (dictionary_files
== NULL
) return 0;
5376 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5384 char *stroptitype (const uint opti_type
)
5388 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5389 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5390 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5391 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5392 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5393 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5394 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5395 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5396 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5397 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5398 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5399 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5400 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5401 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5407 char *strparser (const uint parser_status
)
5409 switch (parser_status
)
5411 case PARSER_OK
: return ((char *) PA_000
); break;
5412 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5413 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5414 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5415 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5416 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5417 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5418 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5419 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5420 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5421 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5422 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5423 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5424 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5425 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5426 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5427 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5430 return ((char *) PA_255
);
5433 char *strhashtype (const uint hash_mode
)
5437 case 0: return ((char *) HT_00000
); break;
5438 case 10: return ((char *) HT_00010
); break;
5439 case 11: return ((char *) HT_00011
); break;
5440 case 12: return ((char *) HT_00012
); break;
5441 case 20: return ((char *) HT_00020
); break;
5442 case 21: return ((char *) HT_00021
); break;
5443 case 22: return ((char *) HT_00022
); break;
5444 case 23: return ((char *) HT_00023
); break;
5445 case 30: return ((char *) HT_00030
); break;
5446 case 40: return ((char *) HT_00040
); break;
5447 case 50: return ((char *) HT_00050
); break;
5448 case 60: return ((char *) HT_00060
); break;
5449 case 100: return ((char *) HT_00100
); break;
5450 case 101: return ((char *) HT_00101
); break;
5451 case 110: return ((char *) HT_00110
); break;
5452 case 111: return ((char *) HT_00111
); break;
5453 case 112: return ((char *) HT_00112
); break;
5454 case 120: return ((char *) HT_00120
); break;
5455 case 121: return ((char *) HT_00121
); break;
5456 case 122: return ((char *) HT_00122
); break;
5457 case 124: return ((char *) HT_00124
); break;
5458 case 130: return ((char *) HT_00130
); break;
5459 case 131: return ((char *) HT_00131
); break;
5460 case 132: return ((char *) HT_00132
); break;
5461 case 133: return ((char *) HT_00133
); break;
5462 case 140: return ((char *) HT_00140
); break;
5463 case 141: return ((char *) HT_00141
); break;
5464 case 150: return ((char *) HT_00150
); break;
5465 case 160: return ((char *) HT_00160
); break;
5466 case 190: return ((char *) HT_00190
); break;
5467 case 200: return ((char *) HT_00200
); break;
5468 case 300: return ((char *) HT_00300
); break;
5469 case 400: return ((char *) HT_00400
); break;
5470 case 500: return ((char *) HT_00500
); break;
5471 case 501: return ((char *) HT_00501
); break;
5472 case 900: return ((char *) HT_00900
); break;
5473 case 910: return ((char *) HT_00910
); break;
5474 case 1000: return ((char *) HT_01000
); break;
5475 case 1100: return ((char *) HT_01100
); break;
5476 case 1400: return ((char *) HT_01400
); break;
5477 case 1410: return ((char *) HT_01410
); break;
5478 case 1420: return ((char *) HT_01420
); break;
5479 case 1421: return ((char *) HT_01421
); break;
5480 case 1430: return ((char *) HT_01430
); break;
5481 case 1440: return ((char *) HT_01440
); break;
5482 case 1441: return ((char *) HT_01441
); break;
5483 case 1450: return ((char *) HT_01450
); break;
5484 case 1460: return ((char *) HT_01460
); break;
5485 case 1500: return ((char *) HT_01500
); break;
5486 case 1600: return ((char *) HT_01600
); break;
5487 case 1700: return ((char *) HT_01700
); break;
5488 case 1710: return ((char *) HT_01710
); break;
5489 case 1711: return ((char *) HT_01711
); break;
5490 case 1720: return ((char *) HT_01720
); break;
5491 case 1722: return ((char *) HT_01722
); break;
5492 case 1730: return ((char *) HT_01730
); break;
5493 case 1731: return ((char *) HT_01731
); break;
5494 case 1740: return ((char *) HT_01740
); break;
5495 case 1750: return ((char *) HT_01750
); break;
5496 case 1760: return ((char *) HT_01760
); break;
5497 case 1800: return ((char *) HT_01800
); break;
5498 case 2100: return ((char *) HT_02100
); break;
5499 case 2400: return ((char *) HT_02400
); break;
5500 case 2410: return ((char *) HT_02410
); break;
5501 case 2500: return ((char *) HT_02500
); break;
5502 case 2600: return ((char *) HT_02600
); break;
5503 case 2611: return ((char *) HT_02611
); break;
5504 case 2612: return ((char *) HT_02612
); break;
5505 case 2711: return ((char *) HT_02711
); break;
5506 case 2811: return ((char *) HT_02811
); break;
5507 case 3000: return ((char *) HT_03000
); break;
5508 case 3100: return ((char *) HT_03100
); break;
5509 case 3200: return ((char *) HT_03200
); break;
5510 case 3710: return ((char *) HT_03710
); break;
5511 case 3711: return ((char *) HT_03711
); break;
5512 case 3800: return ((char *) HT_03800
); break;
5513 case 4300: return ((char *) HT_04300
); break;
5514 case 4400: return ((char *) HT_04400
); break;
5515 case 4500: return ((char *) HT_04500
); break;
5516 case 4700: return ((char *) HT_04700
); break;
5517 case 4800: return ((char *) HT_04800
); break;
5518 case 4900: return ((char *) HT_04900
); break;
5519 case 5000: return ((char *) HT_05000
); break;
5520 case 5100: return ((char *) HT_05100
); break;
5521 case 5200: return ((char *) HT_05200
); break;
5522 case 5300: return ((char *) HT_05300
); break;
5523 case 5400: return ((char *) HT_05400
); break;
5524 case 5500: return ((char *) HT_05500
); break;
5525 case 5600: return ((char *) HT_05600
); break;
5526 case 5700: return ((char *) HT_05700
); break;
5527 case 5800: return ((char *) HT_05800
); break;
5528 case 6000: return ((char *) HT_06000
); break;
5529 case 6100: return ((char *) HT_06100
); break;
5530 case 6211: return ((char *) HT_06211
); break;
5531 case 6212: return ((char *) HT_06212
); break;
5532 case 6213: return ((char *) HT_06213
); break;
5533 case 6221: return ((char *) HT_06221
); break;
5534 case 6222: return ((char *) HT_06222
); break;
5535 case 6223: return ((char *) HT_06223
); break;
5536 case 6231: return ((char *) HT_06231
); break;
5537 case 6232: return ((char *) HT_06232
); break;
5538 case 6233: return ((char *) HT_06233
); break;
5539 case 6241: return ((char *) HT_06241
); break;
5540 case 6242: return ((char *) HT_06242
); break;
5541 case 6243: return ((char *) HT_06243
); break;
5542 case 6300: return ((char *) HT_06300
); break;
5543 case 6400: return ((char *) HT_06400
); break;
5544 case 6500: return ((char *) HT_06500
); break;
5545 case 6600: return ((char *) HT_06600
); break;
5546 case 6700: return ((char *) HT_06700
); break;
5547 case 6800: return ((char *) HT_06800
); break;
5548 case 6900: return ((char *) HT_06900
); break;
5549 case 7100: return ((char *) HT_07100
); break;
5550 case 7200: return ((char *) HT_07200
); break;
5551 case 7300: return ((char *) HT_07300
); break;
5552 case 7400: return ((char *) HT_07400
); break;
5553 case 7500: return ((char *) HT_07500
); break;
5554 case 7600: return ((char *) HT_07600
); break;
5555 case 7700: return ((char *) HT_07700
); break;
5556 case 7800: return ((char *) HT_07800
); break;
5557 case 7900: return ((char *) HT_07900
); break;
5558 case 8000: return ((char *) HT_08000
); break;
5559 case 8100: return ((char *) HT_08100
); break;
5560 case 8200: return ((char *) HT_08200
); break;
5561 case 8300: return ((char *) HT_08300
); break;
5562 case 8400: return ((char *) HT_08400
); break;
5563 case 8500: return ((char *) HT_08500
); break;
5564 case 8600: return ((char *) HT_08600
); break;
5565 case 8700: return ((char *) HT_08700
); break;
5566 case 8800: return ((char *) HT_08800
); break;
5567 case 8900: return ((char *) HT_08900
); break;
5568 case 9000: return ((char *) HT_09000
); break;
5569 case 9100: return ((char *) HT_09100
); break;
5570 case 9200: return ((char *) HT_09200
); break;
5571 case 9300: return ((char *) HT_09300
); break;
5572 case 9400: return ((char *) HT_09400
); break;
5573 case 9500: return ((char *) HT_09500
); break;
5574 case 9600: return ((char *) HT_09600
); break;
5575 case 9700: return ((char *) HT_09700
); break;
5576 case 9710: return ((char *) HT_09710
); break;
5577 case 9720: return ((char *) HT_09720
); break;
5578 case 9800: return ((char *) HT_09800
); break;
5579 case 9810: return ((char *) HT_09810
); break;
5580 case 9820: return ((char *) HT_09820
); break;
5581 case 9900: return ((char *) HT_09900
); break;
5582 case 10000: return ((char *) HT_10000
); break;
5583 case 10100: return ((char *) HT_10100
); break;
5584 case 10200: return ((char *) HT_10200
); break;
5585 case 10300: return ((char *) HT_10300
); break;
5586 case 10400: return ((char *) HT_10400
); break;
5587 case 10410: return ((char *) HT_10410
); break;
5588 case 10420: return ((char *) HT_10420
); break;
5589 case 10500: return ((char *) HT_10500
); break;
5590 case 10600: return ((char *) HT_10600
); break;
5591 case 10700: return ((char *) HT_10700
); break;
5592 case 10800: return ((char *) HT_10800
); break;
5593 case 10900: return ((char *) HT_10900
); break;
5594 case 11000: return ((char *) HT_11000
); break;
5595 case 11100: return ((char *) HT_11100
); break;
5596 case 11200: return ((char *) HT_11200
); break;
5597 case 11300: return ((char *) HT_11300
); break;
5598 case 11400: return ((char *) HT_11400
); break;
5599 case 11500: return ((char *) HT_11500
); break;
5600 case 11600: return ((char *) HT_11600
); break;
5601 case 11700: return ((char *) HT_11700
); break;
5602 case 11800: return ((char *) HT_11800
); break;
5603 case 11900: return ((char *) HT_11900
); break;
5604 case 12000: return ((char *) HT_12000
); break;
5605 case 12100: return ((char *) HT_12100
); break;
5606 case 12200: return ((char *) HT_12200
); break;
5607 case 12300: return ((char *) HT_12300
); break;
5608 case 12400: return ((char *) HT_12400
); break;
5609 case 12500: return ((char *) HT_12500
); break;
5610 case 12600: return ((char *) HT_12600
); break;
5611 case 12700: return ((char *) HT_12700
); break;
5612 case 12800: return ((char *) HT_12800
); break;
5613 case 12900: return ((char *) HT_12900
); break;
5616 return ((char *) "Unknown");
5619 char *strstatus (const uint devices_status
)
5621 switch (devices_status
)
5623 case STATUS_INIT
: return ((char *) ST_0000
); break;
5624 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5625 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5626 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5627 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5628 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5629 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5630 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5631 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5632 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5635 return ((char *) "Unknown");
5638 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5640 uint hash_type
= data
.hash_type
;
5641 uint hash_mode
= data
.hash_mode
;
5642 uint salt_type
= data
.salt_type
;
5643 uint opts_type
= data
.opts_type
;
5644 uint opti_type
= data
.opti_type
;
5645 uint dgst_size
= data
.dgst_size
;
5647 char *hashfile
= data
.hashfile
;
5651 uint digest_buf
[64];
5653 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5655 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5657 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5659 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5665 case HASH_TYPE_DESCRYPT
:
5666 FP (digest_buf
[1], digest_buf
[0], tt
);
5669 case HASH_TYPE_DESRACF
:
5670 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5671 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5673 FP (digest_buf
[1], digest_buf
[0], tt
);
5677 FP (digest_buf
[1], digest_buf
[0], tt
);
5680 case HASH_TYPE_NETNTLM
:
5681 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5682 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5683 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5684 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5686 FP (digest_buf
[1], digest_buf
[0], tt
);
5687 FP (digest_buf
[3], digest_buf
[2], tt
);
5690 case HASH_TYPE_BSDICRYPT
:
5691 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5692 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5694 FP (digest_buf
[1], digest_buf
[0], tt
);
5699 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5704 digest_buf
[0] += MD4M_A
;
5705 digest_buf
[1] += MD4M_B
;
5706 digest_buf
[2] += MD4M_C
;
5707 digest_buf
[3] += MD4M_D
;
5711 digest_buf
[0] += MD5M_A
;
5712 digest_buf
[1] += MD5M_B
;
5713 digest_buf
[2] += MD5M_C
;
5714 digest_buf
[3] += MD5M_D
;
5717 case HASH_TYPE_SHA1
:
5718 digest_buf
[0] += SHA1M_A
;
5719 digest_buf
[1] += SHA1M_B
;
5720 digest_buf
[2] += SHA1M_C
;
5721 digest_buf
[3] += SHA1M_D
;
5722 digest_buf
[4] += SHA1M_E
;
5725 case HASH_TYPE_SHA256
:
5726 digest_buf
[0] += SHA256M_A
;
5727 digest_buf
[1] += SHA256M_B
;
5728 digest_buf
[2] += SHA256M_C
;
5729 digest_buf
[3] += SHA256M_D
;
5730 digest_buf
[4] += SHA256M_E
;
5731 digest_buf
[5] += SHA256M_F
;
5732 digest_buf
[6] += SHA256M_G
;
5733 digest_buf
[7] += SHA256M_H
;
5736 case HASH_TYPE_SHA384
:
5737 digest_buf64
[0] += SHA384M_A
;
5738 digest_buf64
[1] += SHA384M_B
;
5739 digest_buf64
[2] += SHA384M_C
;
5740 digest_buf64
[3] += SHA384M_D
;
5741 digest_buf64
[4] += SHA384M_E
;
5742 digest_buf64
[5] += SHA384M_F
;
5743 digest_buf64
[6] += 0;
5744 digest_buf64
[7] += 0;
5747 case HASH_TYPE_SHA512
:
5748 digest_buf64
[0] += SHA512M_A
;
5749 digest_buf64
[1] += SHA512M_B
;
5750 digest_buf64
[2] += SHA512M_C
;
5751 digest_buf64
[3] += SHA512M_D
;
5752 digest_buf64
[4] += SHA512M_E
;
5753 digest_buf64
[5] += SHA512M_F
;
5754 digest_buf64
[6] += SHA512M_G
;
5755 digest_buf64
[7] += SHA512M_H
;
5760 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5762 if (dgst_size
== DGST_SIZE_4_2
)
5764 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5766 else if (dgst_size
== DGST_SIZE_4_4
)
5768 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5770 else if (dgst_size
== DGST_SIZE_4_5
)
5772 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5774 else if (dgst_size
== DGST_SIZE_4_6
)
5776 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5778 else if (dgst_size
== DGST_SIZE_4_8
)
5780 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5782 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5784 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5786 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5788 else if (hash_type
== HASH_TYPE_SHA384
)
5790 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5792 else if (hash_type
== HASH_TYPE_SHA512
)
5794 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5796 else if (hash_type
== HASH_TYPE_GOST
)
5798 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5801 else if (dgst_size
== DGST_SIZE_4_64
)
5803 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5805 else if (dgst_size
== DGST_SIZE_8_25
)
5807 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5811 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5812 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5813 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5819 memset (&salt
, 0, sizeof (salt_t
));
5821 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5823 char *ptr
= (char *) salt
.salt_buf
;
5825 uint len
= salt
.salt_len
;
5827 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5833 case HASH_TYPE_NETNTLM
:
5835 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5836 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5838 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5844 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5846 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5854 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5856 uint max
= salt
.salt_len
/ 4;
5860 for (uint i
= 0; i
< max
; i
++)
5862 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5866 if (opts_type
& OPTS_TYPE_ST_HEX
)
5870 memset (tmp
, 0, sizeof (tmp
));
5872 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5874 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5879 memcpy (ptr
, tmp
, len
);
5882 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5884 memset (ptr
+ len
, 0, memset_size
);
5886 salt
.salt_len
= len
;
5890 // some modes require special encoding
5893 uint out_buf_plain
[256];
5894 uint out_buf_salt
[256];
5898 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5899 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5901 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5903 char *ptr_plain
= (char *) out_buf_plain
;
5904 char *ptr_salt
= (char *) out_buf_salt
;
5906 if (hash_mode
== 22)
5910 memset (username
, 0, sizeof (username
));
5912 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5914 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5916 uint16_t *ptr
= (uint16_t *) digest_buf
;
5918 tmp_buf
[ 0] = sig
[0];
5919 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5920 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5921 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5922 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5923 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5924 tmp_buf
[ 6] = sig
[1];
5925 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5926 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5927 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5928 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5929 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5930 tmp_buf
[12] = sig
[2];
5931 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5932 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5933 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5934 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5935 tmp_buf
[17] = sig
[3];
5936 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5937 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5938 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5939 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5940 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5941 tmp_buf
[23] = sig
[4];
5942 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5943 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5944 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5945 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5946 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5947 tmp_buf
[29] = sig
[5];
5949 snprintf (out_buf
, len
-1, "%s:%s",
5953 else if (hash_mode
== 23)
5955 // do not show the \nskyper\n part in output
5957 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5959 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5961 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5968 else if (hash_mode
== 101)
5970 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5972 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5973 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5974 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5975 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5976 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5978 memcpy (tmp_buf
, digest_buf
, 20);
5980 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5982 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5984 else if (hash_mode
== 111)
5986 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5988 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5989 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5990 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5991 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5992 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5994 memcpy (tmp_buf
, digest_buf
, 20);
5995 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5997 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5999 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6001 else if (hash_mode
== 122)
6003 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6004 (unsigned char *) salt
.salt_buf
,
6011 else if (hash_mode
== 124)
6013 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6014 (unsigned char *) salt
.salt_buf
,
6021 else if (hash_mode
== 131)
6023 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6024 (unsigned char *) salt
.salt_buf
,
6032 else if (hash_mode
== 132)
6034 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6035 (unsigned char *) salt
.salt_buf
,
6042 else if (hash_mode
== 133)
6044 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6046 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6047 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6048 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6049 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6050 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6052 memcpy (tmp_buf
, digest_buf
, 20);
6054 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6056 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6058 else if (hash_mode
== 141)
6060 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6062 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6064 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6066 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6068 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6069 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6070 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6071 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6072 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6074 memcpy (tmp_buf
, digest_buf
, 20);
6076 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6080 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6082 else if (hash_mode
== 400)
6084 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6086 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6087 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6088 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6089 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6091 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6093 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6095 else if (hash_mode
== 500)
6097 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6099 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6100 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6101 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6102 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6104 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6106 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6108 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6112 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6115 else if (hash_mode
== 501)
6117 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6119 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6120 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6122 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6124 else if (hash_mode
== 1421)
6126 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6128 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6144 else if (hash_mode
== 1441)
6146 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6148 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6150 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6152 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6154 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6155 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6156 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6157 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6158 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6159 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6160 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6161 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6163 memcpy (tmp_buf
, digest_buf
, 32);
6165 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6169 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6171 else if (hash_mode
== 1500)
6173 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6174 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6175 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6176 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6177 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6179 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6181 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6183 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6184 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6186 memcpy (tmp_buf
, digest_buf
, 8);
6188 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6190 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6194 else if (hash_mode
== 1600)
6196 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6198 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6199 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6200 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6201 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6203 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6205 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6207 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6211 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6214 else if (hash_mode
== 1711)
6216 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6218 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6219 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6220 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6221 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6222 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6223 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6224 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6225 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6227 memcpy (tmp_buf
, digest_buf
, 64);
6228 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6230 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6232 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6234 else if (hash_mode
== 1722)
6236 uint
*ptr
= digest_buf
;
6238 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6239 (unsigned char *) salt
.salt_buf
,
6249 else if (hash_mode
== 1731)
6251 uint
*ptr
= digest_buf
;
6253 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6254 (unsigned char *) salt
.salt_buf
,
6264 else if (hash_mode
== 1800)
6268 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6269 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6270 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6271 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6272 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6273 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6274 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6275 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6277 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6279 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6281 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6285 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6288 else if (hash_mode
== 2100)
6292 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6294 salt
.salt_iter
+ 1);
6296 uint signature_len
= strlen (out_buf
);
6298 pos
+= signature_len
;
6299 len
-= signature_len
;
6301 char *salt_ptr
= (char *) salt
.salt_buf
;
6303 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6305 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6306 byte_swap_32 (digest_buf
[0]),
6307 byte_swap_32 (digest_buf
[1]),
6308 byte_swap_32 (digest_buf
[2]),
6309 byte_swap_32 (digest_buf
[3]));
6311 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6313 memcpy (tmp_buf
, digest_buf
, 16);
6315 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6317 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6318 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6319 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6320 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6322 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6323 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6324 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6325 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6327 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6328 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6329 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6330 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6332 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6333 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6334 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6335 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6337 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6338 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6339 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6340 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6344 else if (hash_mode
== 2500)
6346 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6348 wpa_t
*wpa
= &wpas
[salt_pos
];
6352 char *pke_ptr
= (char *) pke
;
6354 for (uint i
= 0; i
< 25; i
++)
6356 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6359 unsigned char mac1
[6];
6360 unsigned char mac2
[6];
6362 memcpy (mac1
, pke_ptr
+ 23, 6);
6363 memcpy (mac2
, pke_ptr
+ 29, 6);
6365 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6366 (char *) salt
.salt_buf
,
6380 else if (hash_mode
== 4400)
6382 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6383 byte_swap_32 (digest_buf
[0]),
6384 byte_swap_32 (digest_buf
[1]),
6385 byte_swap_32 (digest_buf
[2]),
6386 byte_swap_32 (digest_buf
[3]));
6388 else if (hash_mode
== 4700)
6390 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6391 byte_swap_32 (digest_buf
[0]),
6392 byte_swap_32 (digest_buf
[1]),
6393 byte_swap_32 (digest_buf
[2]),
6394 byte_swap_32 (digest_buf
[3]),
6395 byte_swap_32 (digest_buf
[4]));
6397 else if (hash_mode
== 4800)
6399 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6401 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6406 byte_swap_32 (salt
.salt_buf
[0]),
6407 byte_swap_32 (salt
.salt_buf
[1]),
6408 byte_swap_32 (salt
.salt_buf
[2]),
6409 byte_swap_32 (salt
.salt_buf
[3]),
6412 else if (hash_mode
== 4900)
6414 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6415 byte_swap_32 (digest_buf
[0]),
6416 byte_swap_32 (digest_buf
[1]),
6417 byte_swap_32 (digest_buf
[2]),
6418 byte_swap_32 (digest_buf
[3]),
6419 byte_swap_32 (digest_buf
[4]));
6421 else if (hash_mode
== 5100)
6423 snprintf (out_buf
, len
-1, "%08x%08x",
6427 else if (hash_mode
== 5200)
6429 snprintf (out_buf
, len
-1, "%s", hashfile
);
6431 else if (hash_mode
== 5300)
6433 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6435 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6437 int buf_len
= len
-1;
6441 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6443 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6445 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6447 snprintf (out_buf
, buf_len
, ":");
6453 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6461 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6463 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6465 if ((i
== 0) || (i
== 5))
6467 snprintf (out_buf
, buf_len
, ":");
6473 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6481 for (uint i
= 0; i
< 4; i
++)
6485 snprintf (out_buf
, buf_len
, ":");
6491 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6497 else if (hash_mode
== 5400)
6499 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6501 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6503 int buf_len
= len
-1;
6507 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6509 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6511 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6513 snprintf (out_buf
, buf_len
, ":");
6519 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6527 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6529 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6531 if ((i
== 0) || (i
== 5))
6533 snprintf (out_buf
, buf_len
, ":");
6539 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6547 for (uint i
= 0; i
< 5; i
++)
6551 snprintf (out_buf
, buf_len
, ":");
6557 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6563 else if (hash_mode
== 5500)
6565 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6567 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6570 char domain_buf
[64];
6571 char srvchall_buf
[1024];
6572 char clichall_buf
[1024];
6574 memset (user_buf
, 0, sizeof (user_buf
));
6575 memset (domain_buf
, 0, sizeof (domain_buf
));
6576 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6577 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6579 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6581 char *ptr
= (char *) netntlm
->userdomain_buf
;
6583 user_buf
[i
] = ptr
[j
];
6586 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6588 char *ptr
= (char *) netntlm
->userdomain_buf
;
6590 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6593 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6595 char *ptr
= (char *) netntlm
->chall_buf
;
6597 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6600 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6602 char *ptr
= (char *) netntlm
->chall_buf
;
6604 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6607 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6615 byte_swap_32 (salt
.salt_buf_pc
[0]),
6616 byte_swap_32 (salt
.salt_buf_pc
[1]),
6619 else if (hash_mode
== 5600)
6621 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6623 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6626 char domain_buf
[64];
6627 char srvchall_buf
[1024];
6628 char clichall_buf
[1024];
6630 memset (user_buf
, 0, sizeof (user_buf
));
6631 memset (domain_buf
, 0, sizeof (domain_buf
));
6632 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6633 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6635 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6637 char *ptr
= (char *) netntlm
->userdomain_buf
;
6639 user_buf
[i
] = ptr
[j
];
6642 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6644 char *ptr
= (char *) netntlm
->userdomain_buf
;
6646 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6649 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6651 char *ptr
= (char *) netntlm
->chall_buf
;
6653 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6656 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6658 char *ptr
= (char *) netntlm
->chall_buf
;
6660 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6663 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6673 else if (hash_mode
== 5700)
6675 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6677 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6678 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6679 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6680 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6681 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6682 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6683 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6684 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6686 memcpy (tmp_buf
, digest_buf
, 32);
6688 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6692 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6694 else if (hash_mode
== 5800)
6696 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6697 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6698 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6699 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6700 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6702 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6709 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6711 snprintf (out_buf
, len
-1, "%s", hashfile
);
6713 else if (hash_mode
== 6300)
6715 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6717 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6718 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6719 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6720 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6722 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6724 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6726 else if (hash_mode
== 6400)
6728 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6730 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6732 else if (hash_mode
== 6500)
6734 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6736 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6738 else if (hash_mode
== 6600)
6740 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6742 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6744 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6745 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6747 uint buf_len
= len
- 1;
6749 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6752 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6754 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6759 else if (hash_mode
== 6700)
6761 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6763 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6765 else if (hash_mode
== 6800)
6767 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6769 else if (hash_mode
== 7100)
6771 uint
*ptr
= digest_buf
;
6773 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6775 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6779 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6780 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6781 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6782 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6783 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6784 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6785 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6786 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6788 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",
6789 SIGNATURE_SHA512OSX
,
6791 esalt
[ 0], esalt
[ 1],
6792 esalt
[ 2], esalt
[ 3],
6793 esalt
[ 4], esalt
[ 5],
6794 esalt
[ 6], esalt
[ 7],
6802 ptr
[15], ptr
[14]);
6804 else if (hash_mode
== 7200)
6806 uint
*ptr
= digest_buf
;
6808 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6810 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6814 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6816 len_used
= strlen (out_buf
);
6818 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6820 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6822 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6825 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",
6833 ptr
[15], ptr
[14]);
6835 else if (hash_mode
== 7300)
6837 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6839 rakp_t
*rakp
= &rakps
[salt_pos
];
6841 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6843 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6846 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6853 else if (hash_mode
== 7400)
6855 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6857 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6858 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6859 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6860 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6861 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6862 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6863 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6864 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6866 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6868 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6870 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6874 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6877 else if (hash_mode
== 7500)
6879 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6881 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6883 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6884 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6888 char *ptr_data
= data
;
6890 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6892 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6895 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6897 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6902 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6904 (char *) krb5pa
->user
,
6905 (char *) krb5pa
->realm
,
6906 (char *) krb5pa
->salt
,
6909 else if (hash_mode
== 7700)
6911 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6912 (char *) salt
.salt_buf
,
6916 else if (hash_mode
== 7800)
6918 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6919 (char *) salt
.salt_buf
,
6926 else if (hash_mode
== 7900)
6928 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6932 char *tmp
= (char *) salt
.salt_buf_pc
;
6934 ptr_plain
[42] = tmp
[0];
6940 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6942 else if (hash_mode
== 8000)
6944 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6945 (unsigned char *) salt
.salt_buf
,
6955 else if (hash_mode
== 8100)
6957 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6958 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6960 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6961 (unsigned char *) salt
.salt_buf
,
6968 else if (hash_mode
== 8200)
6970 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6972 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6974 char data_buf
[4096];
6976 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6978 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6981 data_buf
[cloudkey
->data_len
* 2] = 0;
6983 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6984 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6985 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6986 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6987 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6988 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6989 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6990 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6992 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6993 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6994 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6995 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6997 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7013 else if (hash_mode
== 8300)
7017 char digest_buf_c
[33];
7019 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
7021 digest_buf_c
[32] = 0;
7025 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7027 char domain_buf_c
[33];
7029 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7031 for (uint i
= 0; i
< salt_pc_len
; i
++)
7033 const char next
= domain_buf_c
[i
];
7035 domain_buf_c
[i
] = '.';
7040 domain_buf_c
[salt_pc_len
] = 0;
7044 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7046 else if (hash_mode
== 8500)
7048 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7050 else if (hash_mode
== 2612)
7052 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7054 (char *) salt
.salt_buf
,
7060 else if (hash_mode
== 3711)
7062 char *salt_ptr
= (char *) salt
.salt_buf
;
7064 salt_ptr
[salt
.salt_len
- 1] = 0;
7066 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7067 SIGNATURE_MEDIAWIKI_B
,
7074 else if (hash_mode
== 8800)
7076 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7078 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7082 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7084 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7089 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7090 SIGNATURE_ANDROIDFDE
,
7091 byte_swap_32 (salt
.salt_buf
[0]),
7092 byte_swap_32 (salt
.salt_buf
[1]),
7093 byte_swap_32 (salt
.salt_buf
[2]),
7094 byte_swap_32 (salt
.salt_buf
[3]),
7095 byte_swap_32 (digest_buf
[0]),
7096 byte_swap_32 (digest_buf
[1]),
7097 byte_swap_32 (digest_buf
[2]),
7098 byte_swap_32 (digest_buf
[3]),
7101 else if (hash_mode
== 8900)
7103 uint N
= salt
.scrypt_N
;
7104 uint r
= salt
.scrypt_r
;
7105 uint p
= salt
.scrypt_p
;
7107 char base64_salt
[32];
7109 memset (base64_salt
, 0, 32);
7111 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7113 memset (tmp_buf
, 0, 46);
7115 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7116 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7117 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7118 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7119 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7120 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7121 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7122 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7123 digest_buf
[8] = 0; // needed for base64_encode ()
7125 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7127 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7135 else if (hash_mode
== 9000)
7137 snprintf (out_buf
, len
-1, "%s", hashfile
);
7139 else if (hash_mode
== 9200)
7143 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7145 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7147 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7151 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7152 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7153 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7154 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7155 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7156 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7157 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7158 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7159 digest_buf
[8] = 0; // needed for base64_encode ()
7162 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7164 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7165 tmp_buf
[43] = 0; // cut it here
7169 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7171 else if (hash_mode
== 9300)
7173 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7174 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7175 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7176 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7177 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7178 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7179 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7180 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7181 digest_buf
[8] = 0; // needed for base64_encode ()
7184 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7186 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7187 tmp_buf
[43] = 0; // cut it here
7189 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7191 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7193 else if (hash_mode
== 9400)
7195 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7197 office2007_t
*office2007
= &office2007s
[salt_pos
];
7199 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7200 SIGNATURE_OFFICE2007
,
7203 office2007
->keySize
,
7209 office2007
->encryptedVerifier
[0],
7210 office2007
->encryptedVerifier
[1],
7211 office2007
->encryptedVerifier
[2],
7212 office2007
->encryptedVerifier
[3],
7213 office2007
->encryptedVerifierHash
[0],
7214 office2007
->encryptedVerifierHash
[1],
7215 office2007
->encryptedVerifierHash
[2],
7216 office2007
->encryptedVerifierHash
[3],
7217 office2007
->encryptedVerifierHash
[4]);
7219 else if (hash_mode
== 9500)
7221 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7223 office2010_t
*office2010
= &office2010s
[salt_pos
];
7225 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,
7231 office2010
->encryptedVerifier
[0],
7232 office2010
->encryptedVerifier
[1],
7233 office2010
->encryptedVerifier
[2],
7234 office2010
->encryptedVerifier
[3],
7235 office2010
->encryptedVerifierHash
[0],
7236 office2010
->encryptedVerifierHash
[1],
7237 office2010
->encryptedVerifierHash
[2],
7238 office2010
->encryptedVerifierHash
[3],
7239 office2010
->encryptedVerifierHash
[4],
7240 office2010
->encryptedVerifierHash
[5],
7241 office2010
->encryptedVerifierHash
[6],
7242 office2010
->encryptedVerifierHash
[7]);
7244 else if (hash_mode
== 9600)
7246 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7248 office2013_t
*office2013
= &office2013s
[salt_pos
];
7250 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,
7256 office2013
->encryptedVerifier
[0],
7257 office2013
->encryptedVerifier
[1],
7258 office2013
->encryptedVerifier
[2],
7259 office2013
->encryptedVerifier
[3],
7260 office2013
->encryptedVerifierHash
[0],
7261 office2013
->encryptedVerifierHash
[1],
7262 office2013
->encryptedVerifierHash
[2],
7263 office2013
->encryptedVerifierHash
[3],
7264 office2013
->encryptedVerifierHash
[4],
7265 office2013
->encryptedVerifierHash
[5],
7266 office2013
->encryptedVerifierHash
[6],
7267 office2013
->encryptedVerifierHash
[7]);
7269 else if (hash_mode
== 9700)
7271 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7273 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7275 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7276 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7277 byte_swap_32 (salt
.salt_buf
[0]),
7278 byte_swap_32 (salt
.salt_buf
[1]),
7279 byte_swap_32 (salt
.salt_buf
[2]),
7280 byte_swap_32 (salt
.salt_buf
[3]),
7281 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7282 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7283 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7284 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7285 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7286 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7287 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7288 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7290 else if (hash_mode
== 9710)
7292 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7294 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7296 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7297 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7298 byte_swap_32 (salt
.salt_buf
[0]),
7299 byte_swap_32 (salt
.salt_buf
[1]),
7300 byte_swap_32 (salt
.salt_buf
[2]),
7301 byte_swap_32 (salt
.salt_buf
[3]),
7302 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7303 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7304 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7305 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7306 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7307 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7308 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7309 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7311 else if (hash_mode
== 9720)
7313 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7315 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7317 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7319 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7320 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7321 byte_swap_32 (salt
.salt_buf
[0]),
7322 byte_swap_32 (salt
.salt_buf
[1]),
7323 byte_swap_32 (salt
.salt_buf
[2]),
7324 byte_swap_32 (salt
.salt_buf
[3]),
7325 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7326 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7327 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7328 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7329 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7330 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7331 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7332 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7339 else if (hash_mode
== 9800)
7341 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7343 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7345 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7346 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7351 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7352 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7353 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7354 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7355 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7356 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7357 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7358 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7359 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7361 else if (hash_mode
== 9810)
7363 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7365 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7367 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7368 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7373 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7374 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7375 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7376 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7377 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7378 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7379 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7380 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7381 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7383 else if (hash_mode
== 9820)
7385 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7387 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7389 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7391 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7392 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7397 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7398 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7399 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7400 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7401 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7402 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7403 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7404 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7405 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7412 else if (hash_mode
== 10000)
7416 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7418 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7420 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7424 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7425 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7426 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7427 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7428 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7429 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7430 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7431 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7432 digest_buf
[8] = 0; // needed for base64_encode ()
7435 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7437 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7441 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7443 else if (hash_mode
== 10100)
7445 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7450 byte_swap_32 (salt
.salt_buf
[0]),
7451 byte_swap_32 (salt
.salt_buf
[1]),
7452 byte_swap_32 (salt
.salt_buf
[2]),
7453 byte_swap_32 (salt
.salt_buf
[3]));
7455 else if (hash_mode
== 10200)
7457 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7459 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7463 char challenge
[100];
7465 memset (challenge
, 0, sizeof (challenge
));
7467 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7473 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7474 (char *) cram_md5
->user
,
7482 memset (response
, 0, sizeof (response
));
7484 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7486 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7488 else if (hash_mode
== 10300)
7492 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7494 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7495 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7497 uint tmp_len
= 20 + salt
.salt_len
;
7501 char base64_encoded
[100];
7503 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7505 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7507 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7509 else if (hash_mode
== 10400)
7511 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7513 pdf_t
*pdf
= &pdfs
[salt_pos
];
7515 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",
7523 byte_swap_32 (pdf
->id_buf
[0]),
7524 byte_swap_32 (pdf
->id_buf
[1]),
7525 byte_swap_32 (pdf
->id_buf
[2]),
7526 byte_swap_32 (pdf
->id_buf
[3]),
7528 byte_swap_32 (pdf
->u_buf
[0]),
7529 byte_swap_32 (pdf
->u_buf
[1]),
7530 byte_swap_32 (pdf
->u_buf
[2]),
7531 byte_swap_32 (pdf
->u_buf
[3]),
7532 byte_swap_32 (pdf
->u_buf
[4]),
7533 byte_swap_32 (pdf
->u_buf
[5]),
7534 byte_swap_32 (pdf
->u_buf
[6]),
7535 byte_swap_32 (pdf
->u_buf
[7]),
7537 byte_swap_32 (pdf
->o_buf
[0]),
7538 byte_swap_32 (pdf
->o_buf
[1]),
7539 byte_swap_32 (pdf
->o_buf
[2]),
7540 byte_swap_32 (pdf
->o_buf
[3]),
7541 byte_swap_32 (pdf
->o_buf
[4]),
7542 byte_swap_32 (pdf
->o_buf
[5]),
7543 byte_swap_32 (pdf
->o_buf
[6]),
7544 byte_swap_32 (pdf
->o_buf
[7])
7547 else if (hash_mode
== 10410)
7549 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7551 pdf_t
*pdf
= &pdfs
[salt_pos
];
7553 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",
7561 byte_swap_32 (pdf
->id_buf
[0]),
7562 byte_swap_32 (pdf
->id_buf
[1]),
7563 byte_swap_32 (pdf
->id_buf
[2]),
7564 byte_swap_32 (pdf
->id_buf
[3]),
7566 byte_swap_32 (pdf
->u_buf
[0]),
7567 byte_swap_32 (pdf
->u_buf
[1]),
7568 byte_swap_32 (pdf
->u_buf
[2]),
7569 byte_swap_32 (pdf
->u_buf
[3]),
7570 byte_swap_32 (pdf
->u_buf
[4]),
7571 byte_swap_32 (pdf
->u_buf
[5]),
7572 byte_swap_32 (pdf
->u_buf
[6]),
7573 byte_swap_32 (pdf
->u_buf
[7]),
7575 byte_swap_32 (pdf
->o_buf
[0]),
7576 byte_swap_32 (pdf
->o_buf
[1]),
7577 byte_swap_32 (pdf
->o_buf
[2]),
7578 byte_swap_32 (pdf
->o_buf
[3]),
7579 byte_swap_32 (pdf
->o_buf
[4]),
7580 byte_swap_32 (pdf
->o_buf
[5]),
7581 byte_swap_32 (pdf
->o_buf
[6]),
7582 byte_swap_32 (pdf
->o_buf
[7])
7585 else if (hash_mode
== 10420)
7587 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7589 pdf_t
*pdf
= &pdfs
[salt_pos
];
7591 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7593 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",
7601 byte_swap_32 (pdf
->id_buf
[0]),
7602 byte_swap_32 (pdf
->id_buf
[1]),
7603 byte_swap_32 (pdf
->id_buf
[2]),
7604 byte_swap_32 (pdf
->id_buf
[3]),
7606 byte_swap_32 (pdf
->u_buf
[0]),
7607 byte_swap_32 (pdf
->u_buf
[1]),
7608 byte_swap_32 (pdf
->u_buf
[2]),
7609 byte_swap_32 (pdf
->u_buf
[3]),
7610 byte_swap_32 (pdf
->u_buf
[4]),
7611 byte_swap_32 (pdf
->u_buf
[5]),
7612 byte_swap_32 (pdf
->u_buf
[6]),
7613 byte_swap_32 (pdf
->u_buf
[7]),
7615 byte_swap_32 (pdf
->o_buf
[0]),
7616 byte_swap_32 (pdf
->o_buf
[1]),
7617 byte_swap_32 (pdf
->o_buf
[2]),
7618 byte_swap_32 (pdf
->o_buf
[3]),
7619 byte_swap_32 (pdf
->o_buf
[4]),
7620 byte_swap_32 (pdf
->o_buf
[5]),
7621 byte_swap_32 (pdf
->o_buf
[6]),
7622 byte_swap_32 (pdf
->o_buf
[7]),
7630 else if (hash_mode
== 10500)
7632 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7634 pdf_t
*pdf
= &pdfs
[salt_pos
];
7636 if (pdf
->id_len
== 32)
7638 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",
7646 byte_swap_32 (pdf
->id_buf
[0]),
7647 byte_swap_32 (pdf
->id_buf
[1]),
7648 byte_swap_32 (pdf
->id_buf
[2]),
7649 byte_swap_32 (pdf
->id_buf
[3]),
7650 byte_swap_32 (pdf
->id_buf
[4]),
7651 byte_swap_32 (pdf
->id_buf
[5]),
7652 byte_swap_32 (pdf
->id_buf
[6]),
7653 byte_swap_32 (pdf
->id_buf
[7]),
7655 byte_swap_32 (pdf
->u_buf
[0]),
7656 byte_swap_32 (pdf
->u_buf
[1]),
7657 byte_swap_32 (pdf
->u_buf
[2]),
7658 byte_swap_32 (pdf
->u_buf
[3]),
7659 byte_swap_32 (pdf
->u_buf
[4]),
7660 byte_swap_32 (pdf
->u_buf
[5]),
7661 byte_swap_32 (pdf
->u_buf
[6]),
7662 byte_swap_32 (pdf
->u_buf
[7]),
7664 byte_swap_32 (pdf
->o_buf
[0]),
7665 byte_swap_32 (pdf
->o_buf
[1]),
7666 byte_swap_32 (pdf
->o_buf
[2]),
7667 byte_swap_32 (pdf
->o_buf
[3]),
7668 byte_swap_32 (pdf
->o_buf
[4]),
7669 byte_swap_32 (pdf
->o_buf
[5]),
7670 byte_swap_32 (pdf
->o_buf
[6]),
7671 byte_swap_32 (pdf
->o_buf
[7])
7676 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",
7684 byte_swap_32 (pdf
->id_buf
[0]),
7685 byte_swap_32 (pdf
->id_buf
[1]),
7686 byte_swap_32 (pdf
->id_buf
[2]),
7687 byte_swap_32 (pdf
->id_buf
[3]),
7689 byte_swap_32 (pdf
->u_buf
[0]),
7690 byte_swap_32 (pdf
->u_buf
[1]),
7691 byte_swap_32 (pdf
->u_buf
[2]),
7692 byte_swap_32 (pdf
->u_buf
[3]),
7693 byte_swap_32 (pdf
->u_buf
[4]),
7694 byte_swap_32 (pdf
->u_buf
[5]),
7695 byte_swap_32 (pdf
->u_buf
[6]),
7696 byte_swap_32 (pdf
->u_buf
[7]),
7698 byte_swap_32 (pdf
->o_buf
[0]),
7699 byte_swap_32 (pdf
->o_buf
[1]),
7700 byte_swap_32 (pdf
->o_buf
[2]),
7701 byte_swap_32 (pdf
->o_buf
[3]),
7702 byte_swap_32 (pdf
->o_buf
[4]),
7703 byte_swap_32 (pdf
->o_buf
[5]),
7704 byte_swap_32 (pdf
->o_buf
[6]),
7705 byte_swap_32 (pdf
->o_buf
[7])
7709 else if (hash_mode
== 10600)
7711 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7713 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7714 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7716 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7718 else if (hash_mode
== 10700)
7720 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7722 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7723 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7725 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7727 else if (hash_mode
== 10900)
7729 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7731 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7732 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7734 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7736 else if (hash_mode
== 11100)
7738 uint32_t salt_challenge
= salt
.salt_buf
[0];
7740 salt_challenge
= byte_swap_32 (salt_challenge
);
7742 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7744 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7745 SIGNATURE_POSTGRESQL_AUTH
,
7753 else if (hash_mode
== 11200)
7755 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7756 SIGNATURE_MYSQL_AUTH
,
7757 (unsigned char *) salt
.salt_buf
,
7764 else if (hash_mode
== 11300)
7766 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7768 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7770 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7771 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7772 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7774 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7775 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7776 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7778 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7780 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7782 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7785 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7787 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7789 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7792 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7794 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7796 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7799 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7800 SIGNATURE_BITCOIN_WALLET
,
7804 (unsigned char *) salt
.salt_buf
,
7812 free (cry_master_buf
);
7814 free (public_key_buf
);
7816 else if (hash_mode
== 11400)
7818 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7820 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7821 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7823 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7825 else if (hash_mode
== 11600)
7827 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7829 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7831 const uint data_len
= seven_zip
->data_len
;
7833 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7835 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7837 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7839 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7842 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7843 SIGNATURE_SEVEN_ZIP
,
7847 (char *) seven_zip
->salt_buf
,
7849 seven_zip
->iv_buf
[0],
7850 seven_zip
->iv_buf
[1],
7851 seven_zip
->iv_buf
[2],
7852 seven_zip
->iv_buf
[3],
7854 seven_zip
->data_len
,
7855 seven_zip
->unpack_size
,
7860 else if (hash_mode
== 11700)
7862 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7872 else if (hash_mode
== 11800)
7874 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7892 else if (hash_mode
== 11900)
7894 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7896 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7897 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7899 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7901 else if (hash_mode
== 12000)
7903 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7905 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7906 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7908 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7910 else if (hash_mode
== 12100)
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
== 12200)
7921 uint
*ptr_digest
= digest_buf
;
7922 uint
*ptr_salt
= salt
.salt_buf
;
7924 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7931 else if (hash_mode
== 12300)
7933 uint
*ptr_digest
= digest_buf
;
7934 uint
*ptr_salt
= salt
.salt_buf
;
7936 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",
7937 ptr_digest
[ 0], ptr_digest
[ 1],
7938 ptr_digest
[ 2], ptr_digest
[ 3],
7939 ptr_digest
[ 4], ptr_digest
[ 5],
7940 ptr_digest
[ 6], ptr_digest
[ 7],
7941 ptr_digest
[ 8], ptr_digest
[ 9],
7942 ptr_digest
[10], ptr_digest
[11],
7943 ptr_digest
[12], ptr_digest
[13],
7944 ptr_digest
[14], ptr_digest
[15],
7950 else if (hash_mode
== 12400)
7952 // encode iteration count
7956 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7957 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7958 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7959 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7964 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7965 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7966 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7967 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7972 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7974 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7975 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7977 memcpy (tmp_buf
, digest_buf
, 8);
7979 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7983 // fill the resulting buffer
7985 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7987 else if (hash_mode
== 12500)
7989 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7991 byte_swap_32 (salt
.salt_buf
[0]),
7992 byte_swap_32 (salt
.salt_buf
[1]),
7998 else if (hash_mode
== 12600)
8000 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8001 digest_buf
[0] + salt
.salt_buf_pc
[0],
8002 digest_buf
[1] + salt
.salt_buf_pc
[1],
8003 digest_buf
[2] + salt
.salt_buf_pc
[2],
8004 digest_buf
[3] + salt
.salt_buf_pc
[3],
8005 digest_buf
[4] + salt
.salt_buf_pc
[4],
8006 digest_buf
[5] + salt
.salt_buf_pc
[5],
8007 digest_buf
[6] + salt
.salt_buf_pc
[6],
8008 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8010 else if (hash_mode
== 12700)
8012 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8014 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8015 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8017 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8019 else if (hash_mode
== 12800)
8021 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
8023 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",
8036 byte_swap_32 (digest_buf
[0]),
8037 byte_swap_32 (digest_buf
[1]),
8038 byte_swap_32 (digest_buf
[2]),
8039 byte_swap_32 (digest_buf
[3]),
8040 byte_swap_32 (digest_buf
[4]),
8041 byte_swap_32 (digest_buf
[5]),
8042 byte_swap_32 (digest_buf
[6]),
8043 byte_swap_32 (digest_buf
[7])
8046 else if (hash_mode
== 12900)
8048 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",
8057 byte_swap_32 (digest_buf
[0]),
8058 byte_swap_32 (digest_buf
[1]),
8059 byte_swap_32 (digest_buf
[2]),
8060 byte_swap_32 (digest_buf
[3]),
8061 byte_swap_32 (digest_buf
[4]),
8062 byte_swap_32 (digest_buf
[5]),
8063 byte_swap_32 (digest_buf
[6]),
8064 byte_swap_32 (digest_buf
[7]),
8073 if (hash_type
== HASH_TYPE_MD4
)
8075 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8081 else if (hash_type
== HASH_TYPE_MD5
)
8083 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8089 else if (hash_type
== HASH_TYPE_SHA1
)
8091 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8098 else if (hash_type
== HASH_TYPE_SHA256
)
8100 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8110 else if (hash_type
== HASH_TYPE_SHA384
)
8112 uint
*ptr
= digest_buf
;
8114 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8122 else if (hash_type
== HASH_TYPE_SHA512
)
8124 uint
*ptr
= digest_buf
;
8126 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8136 else if (hash_type
== HASH_TYPE_LM
)
8138 snprintf (out_buf
, len
-1, "%08x%08x",
8142 else if (hash_type
== HASH_TYPE_ORACLEH
)
8144 snprintf (out_buf
, len
-1, "%08X%08X",
8148 else if (hash_type
== HASH_TYPE_BCRYPT
)
8150 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8151 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8153 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8155 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8157 else if (hash_type
== HASH_TYPE_KECCAK
)
8159 uint
*ptr
= digest_buf
;
8161 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",
8189 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8191 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8193 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8200 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8202 digest_buf
[ 0] = digest_buf
[ 0];
8203 digest_buf
[ 1] = digest_buf
[ 1];
8204 digest_buf
[ 2] = digest_buf
[ 2];
8205 digest_buf
[ 3] = digest_buf
[ 3];
8206 digest_buf
[ 4] = digest_buf
[ 4];
8207 digest_buf
[ 5] = digest_buf
[ 5];
8208 digest_buf
[ 6] = digest_buf
[ 6];
8209 digest_buf
[ 7] = digest_buf
[ 7];
8210 digest_buf
[ 8] = digest_buf
[ 8];
8211 digest_buf
[ 9] = digest_buf
[ 9];
8212 digest_buf
[10] = digest_buf
[10];
8213 digest_buf
[11] = digest_buf
[11];
8214 digest_buf
[12] = digest_buf
[12];
8215 digest_buf
[13] = digest_buf
[13];
8216 digest_buf
[14] = digest_buf
[14];
8217 digest_buf
[15] = digest_buf
[15];
8219 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8237 else if (hash_type
== HASH_TYPE_GOST
)
8239 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8249 else if (hash_type
== HASH_TYPE_MYSQL
)
8251 snprintf (out_buf
, len
-1, "%08x%08x",
8255 else if (hash_type
== HASH_TYPE_LOTUS5
)
8257 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8263 else if (hash_type
== HASH_TYPE_LOTUS6
)
8265 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8266 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8267 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8268 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8272 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8273 memcpy (buf
+ 5, digest_buf
, 9);
8277 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8279 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8282 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8284 else if (hash_type
== HASH_TYPE_LOTUS8
)
8288 memset (buf
, 0, sizeof (buf
));
8292 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8298 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8302 buf
[26] = salt
.salt_buf_pc
[0];
8303 buf
[27] = salt
.salt_buf_pc
[1];
8307 memcpy (buf
+ 28, digest_buf
, 8);
8309 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8313 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8315 else if (hash_type
== HASH_TYPE_CRC32
)
8317 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8321 if (salt_type
== SALT_TYPE_INTERN
)
8323 size_t pos
= strlen (out_buf
);
8325 out_buf
[pos
] = data
.separator
;
8327 char *ptr
= (char *) salt
.salt_buf
;
8329 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8331 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8335 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8337 memset (hccap
, 0, sizeof (hccap_t
));
8339 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8341 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8343 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8344 wpa_t
*wpa
= &wpas
[salt_pos
];
8346 hccap
->keyver
= wpa
->keyver
;
8348 hccap
->eapol_size
= wpa
->eapol_size
;
8350 if (wpa
->keyver
!= 1)
8354 for (uint i
= 0; i
< 64; i
++)
8356 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8359 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8363 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8368 for (int i
= 5; i
< 25; i
++)
8370 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8373 char *pke_ptr
= (char *) pke_tmp
;
8375 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8376 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8377 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8378 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8380 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8382 uint dgst_size
= data
.dgst_size
;
8384 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8386 if (wpa
->keyver
!= 1)
8390 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8391 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8392 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8393 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8395 memcpy (hccap
->keymic
, digest_tmp
, 16);
8399 memcpy (hccap
->keymic
, digest_ptr
, 16);
8403 void SuspendThreads ()
8405 if (data
.devices_status
== STATUS_RUNNING
)
8407 hc_timer_set (&data
.timer_paused
);
8409 data
.devices_status
= STATUS_PAUSED
;
8411 log_info ("Paused");
8415 void ResumeThreads ()
8417 if (data
.devices_status
== STATUS_PAUSED
)
8421 hc_timer_get (data
.timer_paused
, ms_paused
);
8423 data
.ms_paused
+= ms_paused
;
8425 data
.devices_status
= STATUS_RUNNING
;
8427 log_info ("Resumed");
8433 if (data
.devices_status
!= STATUS_RUNNING
) return;
8435 data
.devices_status
= STATUS_BYPASS
;
8437 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8440 void stop_at_checkpoint ()
8442 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8444 if (data
.devices_status
!= STATUS_RUNNING
) return;
8447 // this feature only makes sense if --restore-disable was not specified
8449 if (data
.restore_disable
== 1)
8451 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8456 // check if monitoring of Restore Point updates should be enabled or disabled
8458 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8460 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8462 // save the current restore point value
8464 data
.checkpoint_cur_words
= get_lowest_words_done ();
8466 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8470 data
.devices_status
= STATUS_RUNNING
;
8472 // reset the global value for checkpoint checks
8474 data
.checkpoint_cur_words
= 0;
8476 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8482 if (data
.devices_status
== STATUS_INIT
) return;
8483 if (data
.devices_status
== STATUS_STARTING
) return;
8485 data
.devices_status
= STATUS_ABORTED
;
8490 if (data
.devices_status
== STATUS_INIT
) return;
8491 if (data
.devices_status
== STATUS_STARTING
) return;
8493 data
.devices_status
= STATUS_QUIT
;
8496 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8500 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8504 memset (&st
, 0, sizeof (st
));
8506 stat (kernel_file
, &st
);
8508 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8510 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8512 if (num_read
!= (size_t) st
.st_size
)
8514 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8521 buf
[st
.st_size
] = 0;
8523 for (int i
= 0; i
< num_devices
; i
++)
8525 kernel_lengths
[i
] = (size_t) st
.st_size
;
8527 kernel_sources
[i
] = buf
;
8532 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8540 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8542 FILE *fp
= fopen (dst
, "wb");
8544 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8554 restore_data_t
*init_restore (int argc
, char **argv
)
8556 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8558 if (data
.restore_disable
== 0)
8560 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8564 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8568 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8577 char pidbin
[BUFSIZ
];
8582 memset (pidbin
, 0, sizeof (pidbin
));
8584 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8586 FILE *fd
= fopen (pidbin
, "rb");
8590 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8592 pidbin
[pidbin_len
] = 0;
8596 char *argv0_r
= strrchr (argv
[0], '/');
8598 char *pidbin_r
= strrchr (pidbin
, '/');
8600 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8602 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8604 if (strcmp (argv0_r
, pidbin_r
) == 0)
8606 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8613 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8615 char pidbin2
[BUFSIZ
];
8619 memset (pidbin2
, 0, sizeof (pidbin2
));
8621 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8622 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8624 pidbin
[pidbin_len
] = 0;
8625 pidbin2
[pidbin2_len
] = 0;
8629 if (strcmp (pidbin
, pidbin2
) == 0)
8631 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8639 if (rd
->version_bin
< RESTORE_MIN
)
8641 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8648 memset (rd
, 0, sizeof (restore_data_t
));
8650 rd
->version_bin
= VERSION_BIN
;
8653 rd
->pid
= getpid ();
8655 rd
->pid
= GetCurrentProcessId ();
8658 if (getcwd (rd
->cwd
, 255) == NULL
)
8671 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8673 FILE *fp
= fopen (eff_restore_file
, "rb");
8677 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8682 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8684 log_error ("ERROR: cannot read %s", eff_restore_file
);
8689 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8691 for (uint i
= 0; i
< rd
->argc
; i
++)
8695 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8697 log_error ("ERROR: cannot read %s", eff_restore_file
);
8702 size_t len
= strlen (buf
);
8704 if (len
) buf
[len
- 1] = 0;
8706 rd
->argv
[i
] = mystrdup (buf
);
8713 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8717 log_error ("Restore file is corrupted");
8720 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8722 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8724 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8729 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8733 if (chdir (rd
->cwd
))
8735 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8741 uint64_t get_lowest_words_done ()
8743 uint64_t words_cur
= -1;
8745 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8747 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8749 const uint64_t words_done
= device_param
->words_done
;
8751 if (words_done
< words_cur
) words_cur
= words_done
;
8754 // It's possible that a device's workload isn't finished right after a restore-case.
8755 // In that case, this function would return 0 and overwrite the real restore point
8756 // There's also data.words_cur which is set to rd->words_cur but it changes while
8757 // the attack is running therefore we should stick to rd->words_cur.
8758 // Note that -s influences rd->words_cur we should keep a close look on that.
8760 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
8765 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8767 uint64_t words_cur
= get_lowest_words_done ();
8769 rd
->words_cur
= words_cur
;
8771 FILE *fp
= fopen (new_restore_file
, "wb");
8775 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8780 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8782 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8787 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8789 for (uint i
= 0; i
< rd
->argc
; i
++)
8791 fprintf (fp
, "%s", rd
->argv
[i
]);
8797 fsync (fileno (fp
));
8802 void cycle_restore ()
8804 const char *eff_restore_file
= data
.eff_restore_file
;
8805 const char *new_restore_file
= data
.new_restore_file
;
8807 restore_data_t
*rd
= data
.rd
;
8809 write_restore (new_restore_file
, rd
);
8813 memset (&st
, 0, sizeof(st
));
8815 if (stat (eff_restore_file
, &st
) == 0)
8817 if (unlink (eff_restore_file
))
8819 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8823 if (rename (new_restore_file
, eff_restore_file
))
8825 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8829 void check_checkpoint ()
8831 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8833 uint64_t words_cur
= get_lowest_words_done ();
8835 if (words_cur
!= data
.checkpoint_cur_words
)
8845 uint
set_kernel_accel (uint hash_mode
)
8849 case 0: return GET_ACCEL (0);
8850 case 10: return GET_ACCEL (10);
8851 case 11: return GET_ACCEL (11);
8852 case 12: return GET_ACCEL (12);
8853 case 20: return GET_ACCEL (20);
8854 case 21: return GET_ACCEL (21);
8855 case 22: return GET_ACCEL (22);
8856 case 23: return GET_ACCEL (23);
8857 case 30: return GET_ACCEL (30);
8858 case 40: return GET_ACCEL (40);
8859 case 50: return GET_ACCEL (50);
8860 case 60: return GET_ACCEL (60);
8861 case 100: return GET_ACCEL (100);
8862 case 101: return GET_ACCEL (101);
8863 case 110: return GET_ACCEL (110);
8864 case 111: return GET_ACCEL (111);
8865 case 112: return GET_ACCEL (112);
8866 case 120: return GET_ACCEL (120);
8867 case 121: return GET_ACCEL (121);
8868 case 122: return GET_ACCEL (122);
8869 case 124: return GET_ACCEL (124);
8870 case 130: return GET_ACCEL (130);
8871 case 131: return GET_ACCEL (131);
8872 case 132: return GET_ACCEL (132);
8873 case 133: return GET_ACCEL (133);
8874 case 140: return GET_ACCEL (140);
8875 case 141: return GET_ACCEL (141);
8876 case 150: return GET_ACCEL (150);
8877 case 160: return GET_ACCEL (160);
8878 case 190: return GET_ACCEL (190);
8879 case 200: return GET_ACCEL (200);
8880 case 300: return GET_ACCEL (300);
8881 case 400: return GET_ACCEL (400);
8882 case 500: return GET_ACCEL (500);
8883 case 501: return GET_ACCEL (501);
8884 case 900: return GET_ACCEL (900);
8885 case 910: return GET_ACCEL (910);
8886 case 1000: return GET_ACCEL (1000);
8887 case 1100: return GET_ACCEL (1100);
8888 case 1400: return GET_ACCEL (1400);
8889 case 1410: return GET_ACCEL (1410);
8890 case 1420: return GET_ACCEL (1420);
8891 case 1421: return GET_ACCEL (1421);
8892 case 1430: return GET_ACCEL (1430);
8893 case 1440: return GET_ACCEL (1440);
8894 case 1441: return GET_ACCEL (1441);
8895 case 1450: return GET_ACCEL (1450);
8896 case 1460: return GET_ACCEL (1460);
8897 case 1500: return GET_ACCEL (1500);
8898 case 1600: return GET_ACCEL (1600);
8899 case 1700: return GET_ACCEL (1700);
8900 case 1710: return GET_ACCEL (1710);
8901 case 1711: return GET_ACCEL (1711);
8902 case 1720: return GET_ACCEL (1720);
8903 case 1722: return GET_ACCEL (1722);
8904 case 1730: return GET_ACCEL (1730);
8905 case 1731: return GET_ACCEL (1731);
8906 case 1740: return GET_ACCEL (1740);
8907 case 1750: return GET_ACCEL (1750);
8908 case 1760: return GET_ACCEL (1760);
8909 case 1800: return GET_ACCEL (1800);
8910 case 2100: return GET_ACCEL (2100);
8911 case 2400: return GET_ACCEL (2400);
8912 case 2410: return GET_ACCEL (2410);
8913 case 2500: return GET_ACCEL (2500);
8914 case 2600: return GET_ACCEL (2600);
8915 case 2611: return GET_ACCEL (2611);
8916 case 2612: return GET_ACCEL (2612);
8917 case 2711: return GET_ACCEL (2711);
8918 case 2811: return GET_ACCEL (2811);
8919 case 3000: return GET_ACCEL (3000);
8920 case 3100: return GET_ACCEL (3100);
8921 case 3200: return GET_ACCEL (3200);
8922 case 3710: return GET_ACCEL (3710);
8923 case 3711: return GET_ACCEL (3711);
8924 case 3800: return GET_ACCEL (3800);
8925 case 4300: return GET_ACCEL (4300);
8926 case 4400: return GET_ACCEL (4400);
8927 case 4500: return GET_ACCEL (4500);
8928 case 4700: return GET_ACCEL (4700);
8929 case 4800: return GET_ACCEL (4800);
8930 case 4900: return GET_ACCEL (4900);
8931 case 5000: return GET_ACCEL (5000);
8932 case 5100: return GET_ACCEL (5100);
8933 case 5200: return GET_ACCEL (5200);
8934 case 5300: return GET_ACCEL (5300);
8935 case 5400: return GET_ACCEL (5400);
8936 case 5500: return GET_ACCEL (5500);
8937 case 5600: return GET_ACCEL (5600);
8938 case 5700: return GET_ACCEL (5700);
8939 case 5800: return GET_ACCEL (5800);
8940 case 6000: return GET_ACCEL (6000);
8941 case 6100: return GET_ACCEL (6100);
8942 case 6211: return GET_ACCEL (6211);
8943 case 6212: return GET_ACCEL (6212);
8944 case 6213: return GET_ACCEL (6213);
8945 case 6221: return GET_ACCEL (6221);
8946 case 6222: return GET_ACCEL (6222);
8947 case 6223: return GET_ACCEL (6223);
8948 case 6231: return GET_ACCEL (6231);
8949 case 6232: return GET_ACCEL (6232);
8950 case 6233: return GET_ACCEL (6233);
8951 case 6241: return GET_ACCEL (6241);
8952 case 6242: return GET_ACCEL (6242);
8953 case 6243: return GET_ACCEL (6243);
8954 case 6300: return GET_ACCEL (6300);
8955 case 6400: return GET_ACCEL (6400);
8956 case 6500: return GET_ACCEL (6500);
8957 case 6600: return GET_ACCEL (6600);
8958 case 6700: return GET_ACCEL (6700);
8959 case 6800: return GET_ACCEL (6800);
8960 case 6900: return GET_ACCEL (6900);
8961 case 7100: return GET_ACCEL (7100);
8962 case 7200: return GET_ACCEL (7200);
8963 case 7300: return GET_ACCEL (7300);
8964 case 7400: return GET_ACCEL (7400);
8965 case 7500: return GET_ACCEL (7500);
8966 case 7600: return GET_ACCEL (7600);
8967 case 7700: return GET_ACCEL (7700);
8968 case 7800: return GET_ACCEL (7800);
8969 case 7900: return GET_ACCEL (7900);
8970 case 8000: return GET_ACCEL (8000);
8971 case 8100: return GET_ACCEL (8100);
8972 case 8200: return GET_ACCEL (8200);
8973 case 8300: return GET_ACCEL (8300);
8974 case 8400: return GET_ACCEL (8400);
8975 case 8500: return GET_ACCEL (8500);
8976 case 8600: return GET_ACCEL (8600);
8977 case 8700: return GET_ACCEL (8700);
8978 case 8800: return GET_ACCEL (8800);
8979 case 8900: return GET_ACCEL (8900);
8980 case 9000: return GET_ACCEL (9000);
8981 case 9100: return GET_ACCEL (9100);
8982 case 9200: return GET_ACCEL (9200);
8983 case 9300: return GET_ACCEL (9300);
8984 case 9400: return GET_ACCEL (9400);
8985 case 9500: return GET_ACCEL (9500);
8986 case 9600: return GET_ACCEL (9600);
8987 case 9700: return GET_ACCEL (9700);
8988 case 9710: return GET_ACCEL (9710);
8989 case 9720: return GET_ACCEL (9720);
8990 case 9800: return GET_ACCEL (9800);
8991 case 9810: return GET_ACCEL (9810);
8992 case 9820: return GET_ACCEL (9820);
8993 case 9900: return GET_ACCEL (9900);
8994 case 10000: return GET_ACCEL (10000);
8995 case 10100: return GET_ACCEL (10100);
8996 case 10200: return GET_ACCEL (10200);
8997 case 10300: return GET_ACCEL (10300);
8998 case 10400: return GET_ACCEL (10400);
8999 case 10410: return GET_ACCEL (10410);
9000 case 10420: return GET_ACCEL (10420);
9001 case 10500: return GET_ACCEL (10500);
9002 case 10600: return GET_ACCEL (10600);
9003 case 10700: return GET_ACCEL (10700);
9004 case 10800: return GET_ACCEL (10800);
9005 case 10900: return GET_ACCEL (10900);
9006 case 11000: return GET_ACCEL (11000);
9007 case 11100: return GET_ACCEL (11100);
9008 case 11200: return GET_ACCEL (11200);
9009 case 11300: return GET_ACCEL (11300);
9010 case 11400: return GET_ACCEL (11400);
9011 case 11500: return GET_ACCEL (11500);
9012 case 11600: return GET_ACCEL (11600);
9013 case 11700: return GET_ACCEL (11700);
9014 case 11800: return GET_ACCEL (11800);
9015 case 11900: return GET_ACCEL (11900);
9016 case 12000: return GET_ACCEL (12000);
9017 case 12100: return GET_ACCEL (12100);
9018 case 12200: return GET_ACCEL (12200);
9019 case 12300: return GET_ACCEL (12300);
9020 case 12400: return GET_ACCEL (12400);
9021 case 12500: return GET_ACCEL (12500);
9022 case 12600: return GET_ACCEL (12600);
9023 case 12700: return GET_ACCEL (12700);
9024 case 12800: return GET_ACCEL (12800);
9025 case 12900: return GET_ACCEL (12900);
9031 uint
set_kernel_loops (uint hash_mode
)
9035 case 0: return GET_LOOPS (0);
9036 case 10: return GET_LOOPS (10);
9037 case 11: return GET_LOOPS (11);
9038 case 12: return GET_LOOPS (12);
9039 case 20: return GET_LOOPS (20);
9040 case 21: return GET_LOOPS (21);
9041 case 22: return GET_LOOPS (22);
9042 case 23: return GET_LOOPS (23);
9043 case 30: return GET_LOOPS (30);
9044 case 40: return GET_LOOPS (40);
9045 case 50: return GET_LOOPS (50);
9046 case 60: return GET_LOOPS (60);
9047 case 100: return GET_LOOPS (100);
9048 case 101: return GET_LOOPS (101);
9049 case 110: return GET_LOOPS (110);
9050 case 111: return GET_LOOPS (111);
9051 case 112: return GET_LOOPS (112);
9052 case 120: return GET_LOOPS (120);
9053 case 121: return GET_LOOPS (121);
9054 case 122: return GET_LOOPS (122);
9055 case 124: return GET_LOOPS (124);
9056 case 130: return GET_LOOPS (130);
9057 case 131: return GET_LOOPS (131);
9058 case 132: return GET_LOOPS (132);
9059 case 133: return GET_LOOPS (133);
9060 case 140: return GET_LOOPS (140);
9061 case 141: return GET_LOOPS (141);
9062 case 150: return GET_LOOPS (150);
9063 case 160: return GET_LOOPS (160);
9064 case 190: return GET_LOOPS (190);
9065 case 200: return GET_LOOPS (200);
9066 case 300: return GET_LOOPS (300);
9067 case 400: return GET_LOOPS (400);
9068 case 500: return GET_LOOPS (500);
9069 case 501: return GET_LOOPS (501);
9070 case 900: return GET_LOOPS (900);
9071 case 910: return GET_LOOPS (910);
9072 case 1000: return GET_LOOPS (1000);
9073 case 1100: return GET_LOOPS (1100);
9074 case 1400: return GET_LOOPS (1400);
9075 case 1410: return GET_LOOPS (1410);
9076 case 1420: return GET_LOOPS (1420);
9077 case 1421: return GET_LOOPS (1421);
9078 case 1430: return GET_LOOPS (1430);
9079 case 1440: return GET_LOOPS (1440);
9080 case 1441: return GET_LOOPS (1441);
9081 case 1450: return GET_LOOPS (1450);
9082 case 1460: return GET_LOOPS (1460);
9083 case 1500: return GET_LOOPS (1500);
9084 case 1600: return GET_LOOPS (1600);
9085 case 1700: return GET_LOOPS (1700);
9086 case 1710: return GET_LOOPS (1710);
9087 case 1711: return GET_LOOPS (1711);
9088 case 1720: return GET_LOOPS (1720);
9089 case 1722: return GET_LOOPS (1722);
9090 case 1730: return GET_LOOPS (1730);
9091 case 1731: return GET_LOOPS (1731);
9092 case 1740: return GET_LOOPS (1740);
9093 case 1750: return GET_LOOPS (1750);
9094 case 1760: return GET_LOOPS (1760);
9095 case 1800: return GET_LOOPS (1800);
9096 case 2100: return GET_LOOPS (2100);
9097 case 2400: return GET_LOOPS (2400);
9098 case 2410: return GET_LOOPS (2410);
9099 case 2500: return GET_LOOPS (2500);
9100 case 2600: return GET_LOOPS (2600);
9101 case 2611: return GET_LOOPS (2611);
9102 case 2612: return GET_LOOPS (2612);
9103 case 2711: return GET_LOOPS (2711);
9104 case 2811: return GET_LOOPS (2811);
9105 case 3000: return GET_LOOPS (3000);
9106 case 3100: return GET_LOOPS (3100);
9107 case 3200: return GET_LOOPS (3200);
9108 case 3710: return GET_LOOPS (3710);
9109 case 3711: return GET_LOOPS (3711);
9110 case 3800: return GET_LOOPS (3800);
9111 case 4300: return GET_LOOPS (4300);
9112 case 4400: return GET_LOOPS (4400);
9113 case 4500: return GET_LOOPS (4500);
9114 case 4700: return GET_LOOPS (4700);
9115 case 4800: return GET_LOOPS (4800);
9116 case 4900: return GET_LOOPS (4900);
9117 case 5000: return GET_LOOPS (5000);
9118 case 5100: return GET_LOOPS (5100);
9119 case 5200: return GET_LOOPS (5200);
9120 case 5300: return GET_LOOPS (5300);
9121 case 5400: return GET_LOOPS (5400);
9122 case 5500: return GET_LOOPS (5500);
9123 case 5600: return GET_LOOPS (5600);
9124 case 5700: return GET_LOOPS (5700);
9125 case 5800: return GET_LOOPS (5800);
9126 case 6000: return GET_LOOPS (6000);
9127 case 6100: return GET_LOOPS (6100);
9128 case 6211: return GET_LOOPS (6211);
9129 case 6212: return GET_LOOPS (6212);
9130 case 6213: return GET_LOOPS (6213);
9131 case 6221: return GET_LOOPS (6221);
9132 case 6222: return GET_LOOPS (6222);
9133 case 6223: return GET_LOOPS (6223);
9134 case 6231: return GET_LOOPS (6231);
9135 case 6232: return GET_LOOPS (6232);
9136 case 6233: return GET_LOOPS (6233);
9137 case 6241: return GET_LOOPS (6241);
9138 case 6242: return GET_LOOPS (6242);
9139 case 6243: return GET_LOOPS (6243);
9140 case 6300: return GET_LOOPS (6300);
9141 case 6400: return GET_LOOPS (6400);
9142 case 6500: return GET_LOOPS (6500);
9143 case 6600: return GET_LOOPS (6600);
9144 case 6700: return GET_LOOPS (6700);
9145 case 6800: return GET_LOOPS (6800);
9146 case 6900: return GET_LOOPS (6900);
9147 case 7100: return GET_LOOPS (7100);
9148 case 7200: return GET_LOOPS (7200);
9149 case 7300: return GET_LOOPS (7300);
9150 case 7400: return GET_LOOPS (7400);
9151 case 7500: return GET_LOOPS (7500);
9152 case 7600: return GET_LOOPS (7600);
9153 case 7700: return GET_LOOPS (7700);
9154 case 7800: return GET_LOOPS (7800);
9155 case 7900: return GET_LOOPS (7900);
9156 case 8000: return GET_LOOPS (8000);
9157 case 8100: return GET_LOOPS (8100);
9158 case 8200: return GET_LOOPS (8200);
9159 case 8300: return GET_LOOPS (8300);
9160 case 8400: return GET_LOOPS (8400);
9161 case 8500: return GET_LOOPS (8500);
9162 case 8600: return GET_LOOPS (8600);
9163 case 8700: return GET_LOOPS (8700);
9164 case 8800: return GET_LOOPS (8800);
9165 case 8900: return GET_LOOPS (8900);
9166 case 9000: return GET_LOOPS (9000);
9167 case 9100: return GET_LOOPS (9100);
9168 case 9200: return GET_LOOPS (9200);
9169 case 9300: return GET_LOOPS (9300);
9170 case 9400: return GET_LOOPS (9400);
9171 case 9500: return GET_LOOPS (9500);
9172 case 9600: return GET_LOOPS (9600);
9173 case 9700: return GET_LOOPS (9700);
9174 case 9710: return GET_LOOPS (9710);
9175 case 9720: return GET_LOOPS (9720);
9176 case 9800: return GET_LOOPS (9800);
9177 case 9810: return GET_LOOPS (9810);
9178 case 9820: return GET_LOOPS (9820);
9179 case 9900: return GET_LOOPS (9900);
9180 case 10000: return GET_LOOPS (10000);
9181 case 10100: return GET_LOOPS (10100);
9182 case 10200: return GET_LOOPS (10200);
9183 case 10300: return GET_LOOPS (10300);
9184 case 10400: return GET_LOOPS (10400);
9185 case 10410: return GET_LOOPS (10410);
9186 case 10420: return GET_LOOPS (10420);
9187 case 10500: return GET_LOOPS (10500);
9188 case 10600: return GET_LOOPS (10600);
9189 case 10700: return GET_LOOPS (10700);
9190 case 10800: return GET_LOOPS (10800);
9191 case 10900: return GET_LOOPS (10900);
9192 case 11000: return GET_LOOPS (11000);
9193 case 11100: return GET_LOOPS (11100);
9194 case 11200: return GET_LOOPS (11200);
9195 case 11300: return GET_LOOPS (11300);
9196 case 11400: return GET_LOOPS (11400);
9197 case 11500: return GET_LOOPS (11500);
9198 case 11600: return GET_LOOPS (11600);
9199 case 11700: return GET_LOOPS (11700);
9200 case 11800: return GET_LOOPS (11800);
9201 case 11900: return GET_LOOPS (11900);
9202 case 12000: return GET_LOOPS (12000);
9203 case 12100: return GET_LOOPS (12100);
9204 case 12200: return GET_LOOPS (12200);
9205 case 12300: return GET_LOOPS (12300);
9206 case 12400: return GET_LOOPS (12400);
9207 case 12500: return GET_LOOPS (12500);
9208 case 12600: return GET_LOOPS (12600);
9209 case 12700: return GET_LOOPS (12700);
9210 case 12800: return GET_LOOPS (12800);
9211 case 12900: return GET_LOOPS (12900);
9221 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9225 if (salt_len
> sizeof(tmp
))
9230 memset (tmp
, 0, sizeof (tmp
));
9231 memcpy (tmp
, in
, salt_len
);
9233 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9235 if ((salt_len
% 2) == 0)
9237 uint new_salt_len
= salt_len
/ 2;
9239 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9241 char p0
= tmp
[j
+ 0];
9242 char p1
= tmp
[j
+ 1];
9244 tmp
[i
] = hex_convert (p1
) << 0;
9245 tmp
[i
] |= hex_convert (p0
) << 4;
9248 salt_len
= new_salt_len
;
9255 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9257 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9260 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9262 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9266 uint
*tmp_uint
= (uint
*) tmp
;
9268 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9269 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9270 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9271 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9272 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9273 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9274 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9275 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9276 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9277 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9279 salt_len
= salt_len
* 2;
9287 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9289 lowercase (tmp
, salt_len
);
9292 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9294 uppercase (tmp
, salt_len
);
9297 uint len
= salt_len
;
9299 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9304 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9309 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9311 uint
*tmp_uint
= (uint
*) tmp
;
9317 for (uint i
= 0; i
< max
; i
++)
9319 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9322 // Important: we may need to increase the length of memcpy since
9323 // we don't want to "loose" some swapped bytes (could happen if
9324 // they do not perfectly fit in the 4-byte blocks)
9325 // Memcpy does always copy the bytes in the BE order, but since
9326 // we swapped them, some important bytes could be in positions
9327 // we normally skip with the original len
9329 if (len
% 4) len
+= 4 - (len
% 4);
9332 memcpy (out
, tmp
, len
);
9337 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9339 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9341 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9343 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9345 salt_t
*salt
= hash_buf
->salt
;
9347 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9349 char *iter_pos
= input_buf
+ 4;
9351 salt
->salt_iter
= 1 << atoi (iter_pos
);
9353 char *salt_pos
= strchr (iter_pos
, '$');
9355 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9361 salt
->salt_len
= salt_len
;
9365 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9367 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9369 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9371 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9373 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9374 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9375 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9376 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9378 char *hash_pos
= salt_pos
+ 22;
9380 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9382 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9384 memcpy (digest
, tmp_buf
, 24);
9386 digest
[0] = byte_swap_32 (digest
[0]);
9387 digest
[1] = byte_swap_32 (digest
[1]);
9388 digest
[2] = byte_swap_32 (digest
[2]);
9389 digest
[3] = byte_swap_32 (digest
[3]);
9390 digest
[4] = byte_swap_32 (digest
[4]);
9391 digest
[5] = byte_swap_32 (digest
[5]);
9393 digest
[5] &= ~0xff; // its just 23 not 24 !
9398 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9400 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9402 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9406 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9408 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9410 memcpy (digest
, tmp_buf
, 32);
9412 digest
[0] = byte_swap_32 (digest
[0]);
9413 digest
[1] = byte_swap_32 (digest
[1]);
9414 digest
[2] = byte_swap_32 (digest
[2]);
9415 digest
[3] = byte_swap_32 (digest
[3]);
9416 digest
[4] = byte_swap_32 (digest
[4]);
9417 digest
[5] = byte_swap_32 (digest
[5]);
9418 digest
[6] = byte_swap_32 (digest
[6]);
9419 digest
[7] = byte_swap_32 (digest
[7]);
9421 digest
[0] -= SHA256M_A
;
9422 digest
[1] -= SHA256M_B
;
9423 digest
[2] -= SHA256M_C
;
9424 digest
[3] -= SHA256M_D
;
9425 digest
[4] -= SHA256M_E
;
9426 digest
[5] -= SHA256M_F
;
9427 digest
[6] -= SHA256M_G
;
9428 digest
[7] -= SHA256M_H
;
9433 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9435 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9437 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9439 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9440 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9442 digest
[0] = byte_swap_32 (digest
[0]);
9443 digest
[1] = byte_swap_32 (digest
[1]);
9447 IP (digest
[0], digest
[1], tt
);
9449 digest
[0] = digest
[0];
9450 digest
[1] = digest
[1];
9457 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9459 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9461 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9463 salt_t
*salt
= hash_buf
->salt
;
9465 char *hash_pos
= input_buf
+ 8;
9467 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9468 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9469 digest
[2] = hex_to_uint (&hash_pos
[16]);
9470 digest
[3] = hex_to_uint (&hash_pos
[24]);
9471 digest
[4] = hex_to_uint (&hash_pos
[32]);
9473 digest
[0] -= SHA1M_A
;
9474 digest
[1] -= SHA1M_B
;
9475 digest
[2] -= SHA1M_C
;
9476 digest
[3] -= SHA1M_D
;
9477 digest
[4] -= SHA1M_E
;
9481 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9483 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9485 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9487 salt
->salt_len
= salt_len
;
9492 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9494 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9496 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9498 salt_t
*salt
= hash_buf
->salt
;
9500 char *hash_pos
= input_buf
+ 8;
9502 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9503 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9504 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9505 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9506 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9507 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9508 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9509 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9511 digest
[0] -= SHA512M_A
;
9512 digest
[1] -= SHA512M_B
;
9513 digest
[2] -= SHA512M_C
;
9514 digest
[3] -= SHA512M_D
;
9515 digest
[4] -= SHA512M_E
;
9516 digest
[5] -= SHA512M_F
;
9517 digest
[6] -= SHA512M_G
;
9518 digest
[7] -= SHA512M_H
;
9522 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9524 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9526 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9528 salt
->salt_len
= salt_len
;
9533 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9535 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9537 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9541 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9544 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9546 salt_t
*salt
= hash_buf
->salt
;
9548 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9549 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9550 digest
[2] = hex_to_uint (&input_buf
[16]);
9551 digest
[3] = hex_to_uint (&input_buf
[24]);
9553 digest
[0] = byte_swap_32 (digest
[0]);
9554 digest
[1] = byte_swap_32 (digest
[1]);
9555 digest
[2] = byte_swap_32 (digest
[2]);
9556 digest
[3] = byte_swap_32 (digest
[3]);
9558 digest
[0] -= MD5M_A
;
9559 digest
[1] -= MD5M_B
;
9560 digest
[2] -= MD5M_C
;
9561 digest
[3] -= MD5M_D
;
9563 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9565 uint salt_len
= input_len
- 32 - 1;
9567 char *salt_buf
= input_buf
+ 32 + 1;
9569 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9571 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9573 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9575 salt
->salt_len
= salt_len
;
9580 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9582 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9584 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9588 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9593 char clean_input_buf
[32];
9595 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9596 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9598 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9602 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9608 clean_input_buf
[k
] = input_buf
[i
];
9616 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9618 salt_t
*salt
= hash_buf
->salt
;
9620 char a
, b
, c
, d
, e
, f
;
9622 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9623 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9624 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9625 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9626 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9627 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9629 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9630 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9632 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9633 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9634 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9635 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9636 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9637 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9639 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9640 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9642 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9643 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9644 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9645 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9646 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9647 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9649 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9650 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9652 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9653 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9654 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9655 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9656 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9657 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9659 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9660 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9662 digest
[0] = byte_swap_32 (digest
[0]);
9663 digest
[1] = byte_swap_32 (digest
[1]);
9664 digest
[2] = byte_swap_32 (digest
[2]);
9665 digest
[3] = byte_swap_32 (digest
[3]);
9667 digest
[0] -= MD5M_A
;
9668 digest
[1] -= MD5M_B
;
9669 digest
[2] -= MD5M_C
;
9670 digest
[3] -= MD5M_D
;
9672 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9674 uint salt_len
= input_len
- 30 - 1;
9676 char *salt_buf
= input_buf
+ 30 + 1;
9678 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9680 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9682 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9683 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9685 salt
->salt_len
= salt_len
;
9687 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9689 salt
->salt_len
+= 22;
9694 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9696 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9698 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9702 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9705 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9707 salt_t
*salt
= hash_buf
->salt
;
9709 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9710 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9711 digest
[2] = hex_to_uint (&input_buf
[16]);
9712 digest
[3] = hex_to_uint (&input_buf
[24]);
9713 digest
[4] = hex_to_uint (&input_buf
[32]);
9715 digest
[0] -= SHA1M_A
;
9716 digest
[1] -= SHA1M_B
;
9717 digest
[2] -= SHA1M_C
;
9718 digest
[3] -= SHA1M_D
;
9719 digest
[4] -= SHA1M_E
;
9721 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9723 uint salt_len
= input_len
- 40 - 1;
9725 char *salt_buf
= input_buf
+ 40 + 1;
9727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9729 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9731 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9733 salt
->salt_len
= salt_len
;
9738 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9740 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9742 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9746 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9749 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9751 char *iter_pos
= input_buf
+ 6;
9753 salt_t
*salt
= hash_buf
->salt
;
9755 salt
->salt_iter
= atoi (iter_pos
) - 1;
9757 char *salt_pos
= strchr (iter_pos
, '#');
9759 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9763 char *digest_pos
= strchr (salt_pos
, '#');
9765 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9769 uint salt_len
= digest_pos
- salt_pos
- 1;
9771 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9773 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9774 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9775 digest
[2] = hex_to_uint (&digest_pos
[16]);
9776 digest
[3] = hex_to_uint (&digest_pos
[24]);
9778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9780 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9782 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9784 salt
->salt_len
= salt_len
;
9789 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9791 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9793 salt_t
*salt
= hash_buf
->salt
;
9795 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9799 memcpy (&in
, input_buf
, input_len
);
9801 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9803 memcpy (digest
, in
.keymic
, 16);
9806 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9807 The phrase "Pairwise key expansion"
9808 Access Point Address (Referred to as Authenticator Address AA)
9809 Supplicant Address (referred to as Supplicant Address SA)
9810 Access Point Nonce (referred to as Authenticator Anonce)
9811 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9814 uint salt_len
= strlen (in
.essid
);
9816 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9818 salt
->salt_len
= salt_len
;
9820 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9822 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9824 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9826 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9828 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9829 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9833 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9834 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9837 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9839 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9840 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9844 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9845 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9848 for (int i
= 0; i
< 25; i
++)
9850 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9853 wpa
->keyver
= in
.keyver
;
9855 if (wpa
->keyver
> 255)
9857 log_info ("ATTENTION!");
9858 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9859 log_info (" This could be due to a recent aircrack-ng bug.");
9860 log_info (" The key version was automatically reset to a reasonable value.");
9863 wpa
->keyver
&= 0xff;
9866 wpa
->eapol_size
= in
.eapol_size
;
9868 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9870 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9872 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9874 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9876 if (wpa
->keyver
== 1)
9882 digest
[0] = byte_swap_32 (digest
[0]);
9883 digest
[1] = byte_swap_32 (digest
[1]);
9884 digest
[2] = byte_swap_32 (digest
[2]);
9885 digest
[3] = byte_swap_32 (digest
[3]);
9887 for (int i
= 0; i
< 64; i
++)
9889 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9893 salt
->salt_buf
[10] = digest
[1];
9894 salt
->salt_buf
[11] = digest
[2];
9899 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9901 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9903 salt_t
*salt
= hash_buf
->salt
;
9907 log_error ("Password Safe v2 container not specified");
9912 FILE *fp
= fopen (input_buf
, "rb");
9916 log_error ("%s: %s", input_buf
, strerror (errno
));
9925 uint32_t salt
[5]; // unused, but makes better valid check
9926 uint32_t iv
[2]; // unused, but makes better valid check
9932 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9936 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9938 salt
->salt_buf
[0] = buf
.random
[0];
9939 salt
->salt_buf
[1] = buf
.random
[1];
9942 salt
->salt_iter
= 1000;
9944 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9945 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9946 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9947 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9948 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9953 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9955 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9957 salt_t
*salt
= hash_buf
->salt
;
9961 log_error (".psafe3 not specified");
9966 FILE *fp
= fopen (input_buf
, "rb");
9970 log_error ("%s: %s", input_buf
, strerror (errno
));
9977 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9981 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9983 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9985 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9987 salt
->salt_iter
= in
.iterations
+ 1;
9989 salt
->salt_buf
[0] = in
.salt_buf
[0];
9990 salt
->salt_buf
[1] = in
.salt_buf
[1];
9991 salt
->salt_buf
[2] = in
.salt_buf
[2];
9992 salt
->salt_buf
[3] = in
.salt_buf
[3];
9993 salt
->salt_buf
[4] = in
.salt_buf
[4];
9994 salt
->salt_buf
[5] = in
.salt_buf
[5];
9995 salt
->salt_buf
[6] = in
.salt_buf
[6];
9996 salt
->salt_buf
[7] = in
.salt_buf
[7];
9998 salt
->salt_len
= 32;
10000 digest
[0] = in
.hash_buf
[0];
10001 digest
[1] = in
.hash_buf
[1];
10002 digest
[2] = in
.hash_buf
[2];
10003 digest
[3] = in
.hash_buf
[3];
10004 digest
[4] = in
.hash_buf
[4];
10005 digest
[5] = in
.hash_buf
[5];
10006 digest
[6] = in
.hash_buf
[6];
10007 digest
[7] = in
.hash_buf
[7];
10009 digest
[0] = byte_swap_32 (digest
[0]);
10010 digest
[1] = byte_swap_32 (digest
[1]);
10011 digest
[2] = byte_swap_32 (digest
[2]);
10012 digest
[3] = byte_swap_32 (digest
[3]);
10013 digest
[4] = byte_swap_32 (digest
[4]);
10014 digest
[5] = byte_swap_32 (digest
[5]);
10015 digest
[6] = byte_swap_32 (digest
[6]);
10016 digest
[7] = byte_swap_32 (digest
[7]);
10018 return (PARSER_OK
);
10021 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10023 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10025 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10027 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10029 salt_t
*salt
= hash_buf
->salt
;
10031 char *iter_pos
= input_buf
+ 3;
10033 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10035 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10037 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10039 salt
->salt_iter
= salt_iter
;
10041 char *salt_pos
= iter_pos
+ 1;
10045 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10047 salt
->salt_len
= salt_len
;
10049 char *hash_pos
= salt_pos
+ salt_len
;
10051 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10053 return (PARSER_OK
);
10056 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10058 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10060 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10062 salt_t
*salt
= hash_buf
->salt
;
10064 char *salt_pos
= input_buf
+ 3;
10066 uint iterations_len
= 0;
10068 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10072 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10074 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10075 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10079 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10083 iterations_len
+= 8;
10087 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10090 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10092 char *hash_pos
= strchr (salt_pos
, '$');
10094 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10096 uint salt_len
= hash_pos
- salt_pos
;
10098 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10100 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10102 salt
->salt_len
= salt_len
;
10106 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10108 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10110 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10112 return (PARSER_OK
);
10115 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10117 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10119 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10121 salt_t
*salt
= hash_buf
->salt
;
10123 char *salt_pos
= input_buf
+ 6;
10125 uint iterations_len
= 0;
10127 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10131 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10133 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10134 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10138 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10142 iterations_len
+= 8;
10146 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10149 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10151 char *hash_pos
= strchr (salt_pos
, '$');
10153 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10155 uint salt_len
= hash_pos
- salt_pos
;
10157 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10159 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10161 salt
->salt_len
= salt_len
;
10165 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10167 return (PARSER_OK
);
10170 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10172 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10174 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10176 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10178 salt_t
*salt
= hash_buf
->salt
;
10180 char *salt_pos
= input_buf
+ 14;
10182 char *hash_pos
= strchr (salt_pos
, '*');
10184 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10188 uint salt_len
= hash_pos
- salt_pos
- 1;
10190 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10192 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10194 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10196 salt
->salt_len
= salt_len
;
10198 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10200 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10202 memcpy (digest
, tmp_buf
, 20);
10204 digest
[0] = byte_swap_32 (digest
[0]);
10205 digest
[1] = byte_swap_32 (digest
[1]);
10206 digest
[2] = byte_swap_32 (digest
[2]);
10207 digest
[3] = byte_swap_32 (digest
[3]);
10208 digest
[4] = byte_swap_32 (digest
[4]);
10210 digest
[0] -= SHA1M_A
;
10211 digest
[1] -= SHA1M_B
;
10212 digest
[2] -= SHA1M_C
;
10213 digest
[3] -= SHA1M_D
;
10214 digest
[4] -= SHA1M_E
;
10216 return (PARSER_OK
);
10219 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10221 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10223 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10225 if (c12
& 3) return (PARSER_HASH_VALUE
);
10227 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10229 salt_t
*salt
= hash_buf
->salt
;
10231 // for ascii_digest
10232 salt
->salt_sign
[0] = input_buf
[0];
10233 salt
->salt_sign
[1] = input_buf
[1];
10235 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10236 | itoa64_to_int (input_buf
[1]) << 6;
10238 salt
->salt_len
= 2;
10242 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10244 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10246 memcpy (digest
, tmp_buf
, 8);
10250 IP (digest
[0], digest
[1], tt
);
10255 return (PARSER_OK
);
10258 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10260 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10262 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10264 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10265 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10266 digest
[2] = hex_to_uint (&input_buf
[16]);
10267 digest
[3] = hex_to_uint (&input_buf
[24]);
10269 digest
[0] = byte_swap_32 (digest
[0]);
10270 digest
[1] = byte_swap_32 (digest
[1]);
10271 digest
[2] = byte_swap_32 (digest
[2]);
10272 digest
[3] = byte_swap_32 (digest
[3]);
10274 digest
[0] -= MD4M_A
;
10275 digest
[1] -= MD4M_B
;
10276 digest
[2] -= MD4M_C
;
10277 digest
[3] -= MD4M_D
;
10279 return (PARSER_OK
);
10282 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10284 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10286 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10290 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10293 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10295 salt_t
*salt
= hash_buf
->salt
;
10297 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10298 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10299 digest
[2] = hex_to_uint (&input_buf
[16]);
10300 digest
[3] = hex_to_uint (&input_buf
[24]);
10302 digest
[0] = byte_swap_32 (digest
[0]);
10303 digest
[1] = byte_swap_32 (digest
[1]);
10304 digest
[2] = byte_swap_32 (digest
[2]);
10305 digest
[3] = byte_swap_32 (digest
[3]);
10307 digest
[0] -= MD4M_A
;
10308 digest
[1] -= MD4M_B
;
10309 digest
[2] -= MD4M_C
;
10310 digest
[3] -= MD4M_D
;
10312 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10314 uint salt_len
= input_len
- 32 - 1;
10316 char *salt_buf
= input_buf
+ 32 + 1;
10318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10324 salt
->salt_len
= salt_len
;
10326 return (PARSER_OK
);
10329 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10331 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10333 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10335 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10336 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10337 digest
[2] = hex_to_uint (&input_buf
[16]);
10338 digest
[3] = hex_to_uint (&input_buf
[24]);
10340 digest
[0] = byte_swap_32 (digest
[0]);
10341 digest
[1] = byte_swap_32 (digest
[1]);
10342 digest
[2] = byte_swap_32 (digest
[2]);
10343 digest
[3] = byte_swap_32 (digest
[3]);
10345 digest
[0] -= MD5M_A
;
10346 digest
[1] -= MD5M_B
;
10347 digest
[2] -= MD5M_C
;
10348 digest
[3] -= MD5M_D
;
10350 return (PARSER_OK
);
10353 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10355 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10357 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10359 digest
[0] = hex_to_uint (&input_buf
[0]);
10360 digest
[1] = hex_to_uint (&input_buf
[8]);
10364 digest
[0] = byte_swap_32 (digest
[0]);
10365 digest
[1] = byte_swap_32 (digest
[1]);
10367 return (PARSER_OK
);
10370 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10372 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10374 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10378 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10381 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10383 salt_t
*salt
= hash_buf
->salt
;
10385 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10386 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10387 digest
[2] = hex_to_uint (&input_buf
[16]);
10388 digest
[3] = hex_to_uint (&input_buf
[24]);
10390 digest
[0] = byte_swap_32 (digest
[0]);
10391 digest
[1] = byte_swap_32 (digest
[1]);
10392 digest
[2] = byte_swap_32 (digest
[2]);
10393 digest
[3] = byte_swap_32 (digest
[3]);
10395 digest
[0] -= MD5M_A
;
10396 digest
[1] -= MD5M_B
;
10397 digest
[2] -= MD5M_C
;
10398 digest
[3] -= MD5M_D
;
10400 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10402 uint salt_len
= input_len
- 32 - 1;
10404 char *salt_buf
= input_buf
+ 32 + 1;
10406 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10408 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10410 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10412 salt
->salt_len
= salt_len
;
10414 return (PARSER_OK
);
10417 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10419 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10421 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10423 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10424 | itoa64_to_int (input_buf
[ 1]) << 6
10425 | itoa64_to_int (input_buf
[ 2]) << 12
10426 | itoa64_to_int (input_buf
[ 3]) << 18;
10427 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10428 | itoa64_to_int (input_buf
[ 5]) << 6
10429 | itoa64_to_int (input_buf
[ 6]) << 12
10430 | itoa64_to_int (input_buf
[ 7]) << 18;
10431 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10432 | itoa64_to_int (input_buf
[ 9]) << 6
10433 | itoa64_to_int (input_buf
[10]) << 12
10434 | itoa64_to_int (input_buf
[11]) << 18;
10435 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10436 | itoa64_to_int (input_buf
[13]) << 6
10437 | itoa64_to_int (input_buf
[14]) << 12
10438 | itoa64_to_int (input_buf
[15]) << 18;
10440 digest
[0] -= MD5M_A
;
10441 digest
[1] -= MD5M_B
;
10442 digest
[2] -= MD5M_C
;
10443 digest
[3] -= MD5M_D
;
10445 digest
[0] &= 0x00ffffff;
10446 digest
[1] &= 0x00ffffff;
10447 digest
[2] &= 0x00ffffff;
10448 digest
[3] &= 0x00ffffff;
10450 return (PARSER_OK
);
10453 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10455 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10457 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10461 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10464 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10466 salt_t
*salt
= hash_buf
->salt
;
10468 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10469 | itoa64_to_int (input_buf
[ 1]) << 6
10470 | itoa64_to_int (input_buf
[ 2]) << 12
10471 | itoa64_to_int (input_buf
[ 3]) << 18;
10472 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10473 | itoa64_to_int (input_buf
[ 5]) << 6
10474 | itoa64_to_int (input_buf
[ 6]) << 12
10475 | itoa64_to_int (input_buf
[ 7]) << 18;
10476 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10477 | itoa64_to_int (input_buf
[ 9]) << 6
10478 | itoa64_to_int (input_buf
[10]) << 12
10479 | itoa64_to_int (input_buf
[11]) << 18;
10480 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10481 | itoa64_to_int (input_buf
[13]) << 6
10482 | itoa64_to_int (input_buf
[14]) << 12
10483 | itoa64_to_int (input_buf
[15]) << 18;
10485 digest
[0] -= MD5M_A
;
10486 digest
[1] -= MD5M_B
;
10487 digest
[2] -= MD5M_C
;
10488 digest
[3] -= MD5M_D
;
10490 digest
[0] &= 0x00ffffff;
10491 digest
[1] &= 0x00ffffff;
10492 digest
[2] &= 0x00ffffff;
10493 digest
[3] &= 0x00ffffff;
10495 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10497 uint salt_len
= input_len
- 16 - 1;
10499 char *salt_buf
= input_buf
+ 16 + 1;
10501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10503 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10505 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10507 salt
->salt_len
= salt_len
;
10509 return (PARSER_OK
);
10512 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10514 key
[0] = (nthash
[0] >> 0);
10515 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10516 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10517 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10518 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10519 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10520 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10521 key
[7] = (nthash
[6] << 1);
10533 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10535 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10537 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10539 salt_t
*salt
= hash_buf
->salt
;
10541 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10547 char *user_pos
= input_buf
;
10549 char *unused_pos
= strchr (user_pos
, ':');
10551 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10553 uint user_len
= unused_pos
- user_pos
;
10555 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10559 char *domain_pos
= strchr (unused_pos
, ':');
10561 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10563 uint unused_len
= domain_pos
- unused_pos
;
10565 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10569 char *srvchall_pos
= strchr (domain_pos
, ':');
10571 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10573 uint domain_len
= srvchall_pos
- domain_pos
;
10575 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10579 char *hash_pos
= strchr (srvchall_pos
, ':');
10581 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10583 uint srvchall_len
= hash_pos
- srvchall_pos
;
10585 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10589 char *clichall_pos
= strchr (hash_pos
, ':');
10591 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10593 uint hash_len
= clichall_pos
- hash_pos
;
10595 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10599 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10601 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10604 * store some data for later use
10607 netntlm
->user_len
= user_len
* 2;
10608 netntlm
->domain_len
= domain_len
* 2;
10609 netntlm
->srvchall_len
= srvchall_len
/ 2;
10610 netntlm
->clichall_len
= clichall_len
/ 2;
10612 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10613 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10616 * handle username and domainname
10619 for (uint i
= 0; i
< user_len
; i
++)
10621 *userdomain_ptr
++ = user_pos
[i
];
10622 *userdomain_ptr
++ = 0;
10625 for (uint i
= 0; i
< domain_len
; i
++)
10627 *userdomain_ptr
++ = domain_pos
[i
];
10628 *userdomain_ptr
++ = 0;
10632 * handle server challenge encoding
10635 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10637 const char p0
= srvchall_pos
[i
+ 0];
10638 const char p1
= srvchall_pos
[i
+ 1];
10640 *chall_ptr
++ = hex_convert (p1
) << 0
10641 | hex_convert (p0
) << 4;
10645 * handle client challenge encoding
10648 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10650 const char p0
= clichall_pos
[i
+ 0];
10651 const char p1
= clichall_pos
[i
+ 1];
10653 *chall_ptr
++ = hex_convert (p1
) << 0
10654 | hex_convert (p0
) << 4;
10661 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10663 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10665 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10667 salt
->salt_len
= salt_len
;
10669 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10670 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10671 digest
[2] = hex_to_uint (&hash_pos
[16]);
10672 digest
[3] = hex_to_uint (&hash_pos
[24]);
10674 digest
[0] = byte_swap_32 (digest
[0]);
10675 digest
[1] = byte_swap_32 (digest
[1]);
10676 digest
[2] = byte_swap_32 (digest
[2]);
10677 digest
[3] = byte_swap_32 (digest
[3]);
10679 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10681 uint digest_tmp
[2];
10683 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10684 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10686 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10687 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10689 /* special case 2: ESS */
10691 if (srvchall_len
== 48)
10693 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10697 w
[ 0] = netntlm
->chall_buf
[6];
10698 w
[ 1] = netntlm
->chall_buf
[7];
10699 w
[ 2] = netntlm
->chall_buf
[0];
10700 w
[ 3] = netntlm
->chall_buf
[1];
10723 salt
->salt_buf
[0] = dgst
[0];
10724 salt
->salt_buf
[1] = dgst
[1];
10728 /* precompute netntlmv1 exploit start */
10730 for (uint i
= 0; i
< 0x10000; i
++)
10732 uint key_md4
[2] = { i
, 0 };
10733 uint key_des
[2] = { 0, 0 };
10735 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10740 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10742 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10744 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10746 if (data3
[0] != digest_tmp
[0]) continue;
10747 if (data3
[1] != digest_tmp
[1]) continue;
10749 salt
->salt_buf
[2] = i
;
10751 salt
->salt_len
= 24;
10756 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10757 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10759 /* precompute netntlmv1 exploit stop */
10763 IP (digest
[0], digest
[1], tt
);
10764 IP (digest
[2], digest
[3], tt
);
10766 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10767 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10768 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10769 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10771 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10773 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10774 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10776 return (PARSER_OK
);
10779 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10781 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10783 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10785 salt_t
*salt
= hash_buf
->salt
;
10787 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10793 char *user_pos
= input_buf
;
10795 char *unused_pos
= strchr (user_pos
, ':');
10797 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10799 uint user_len
= unused_pos
- user_pos
;
10801 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10805 char *domain_pos
= strchr (unused_pos
, ':');
10807 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10809 uint unused_len
= domain_pos
- unused_pos
;
10811 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10815 char *srvchall_pos
= strchr (domain_pos
, ':');
10817 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10819 uint domain_len
= srvchall_pos
- domain_pos
;
10821 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10825 char *hash_pos
= strchr (srvchall_pos
, ':');
10827 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10829 uint srvchall_len
= hash_pos
- srvchall_pos
;
10831 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10835 char *clichall_pos
= strchr (hash_pos
, ':');
10837 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10839 uint hash_len
= clichall_pos
- hash_pos
;
10841 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10845 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10847 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10849 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10852 * store some data for later use
10855 netntlm
->user_len
= user_len
* 2;
10856 netntlm
->domain_len
= domain_len
* 2;
10857 netntlm
->srvchall_len
= srvchall_len
/ 2;
10858 netntlm
->clichall_len
= clichall_len
/ 2;
10860 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10861 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10864 * handle username and domainname
10867 for (uint i
= 0; i
< user_len
; i
++)
10869 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10870 *userdomain_ptr
++ = 0;
10873 for (uint i
= 0; i
< domain_len
; i
++)
10875 *userdomain_ptr
++ = domain_pos
[i
];
10876 *userdomain_ptr
++ = 0;
10879 *userdomain_ptr
++ = 0x80;
10882 * handle server challenge encoding
10885 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10887 const char p0
= srvchall_pos
[i
+ 0];
10888 const char p1
= srvchall_pos
[i
+ 1];
10890 *chall_ptr
++ = hex_convert (p1
) << 0
10891 | hex_convert (p0
) << 4;
10895 * handle client challenge encoding
10898 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10900 const char p0
= clichall_pos
[i
+ 0];
10901 const char p1
= clichall_pos
[i
+ 1];
10903 *chall_ptr
++ = hex_convert (p1
) << 0
10904 | hex_convert (p0
) << 4;
10907 *chall_ptr
++ = 0x80;
10910 * handle hash itself
10913 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10914 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10915 digest
[2] = hex_to_uint (&hash_pos
[16]);
10916 digest
[3] = hex_to_uint (&hash_pos
[24]);
10918 digest
[0] = byte_swap_32 (digest
[0]);
10919 digest
[1] = byte_swap_32 (digest
[1]);
10920 digest
[2] = byte_swap_32 (digest
[2]);
10921 digest
[3] = byte_swap_32 (digest
[3]);
10924 * reuse challange data as salt_buf, its the buffer that is most likely unique
10927 salt
->salt_buf
[0] = 0;
10928 salt
->salt_buf
[1] = 0;
10929 salt
->salt_buf
[2] = 0;
10930 salt
->salt_buf
[3] = 0;
10931 salt
->salt_buf
[4] = 0;
10932 salt
->salt_buf
[5] = 0;
10933 salt
->salt_buf
[6] = 0;
10934 salt
->salt_buf
[7] = 0;
10938 uptr
= (uint
*) netntlm
->userdomain_buf
;
10940 for (uint i
= 0; i
< 16; i
+= 16)
10942 md5_64 (uptr
, salt
->salt_buf
);
10945 uptr
= (uint
*) netntlm
->chall_buf
;
10947 for (uint i
= 0; i
< 256; i
+= 16)
10949 md5_64 (uptr
, salt
->salt_buf
);
10952 salt
->salt_len
= 16;
10954 return (PARSER_OK
);
10957 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10959 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10961 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10965 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10968 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10970 salt_t
*salt
= hash_buf
->salt
;
10972 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10973 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10974 digest
[2] = hex_to_uint (&input_buf
[16]);
10975 digest
[3] = hex_to_uint (&input_buf
[24]);
10977 digest
[0] = byte_swap_32 (digest
[0]);
10978 digest
[1] = byte_swap_32 (digest
[1]);
10979 digest
[2] = byte_swap_32 (digest
[2]);
10980 digest
[3] = byte_swap_32 (digest
[3]);
10982 digest
[0] -= MD5M_A
;
10983 digest
[1] -= MD5M_B
;
10984 digest
[2] -= MD5M_C
;
10985 digest
[3] -= MD5M_D
;
10987 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10989 uint salt_len
= input_len
- 32 - 1;
10991 char *salt_buf
= input_buf
+ 32 + 1;
10993 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10995 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10997 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10999 salt
->salt_len
= salt_len
;
11001 return (PARSER_OK
);
11004 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11006 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11008 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11012 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11015 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11017 salt_t
*salt
= hash_buf
->salt
;
11019 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11020 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11021 digest
[2] = hex_to_uint (&input_buf
[16]);
11022 digest
[3] = hex_to_uint (&input_buf
[24]);
11024 digest
[0] = byte_swap_32 (digest
[0]);
11025 digest
[1] = byte_swap_32 (digest
[1]);
11026 digest
[2] = byte_swap_32 (digest
[2]);
11027 digest
[3] = byte_swap_32 (digest
[3]);
11029 digest
[0] -= MD5M_A
;
11030 digest
[1] -= MD5M_B
;
11031 digest
[2] -= MD5M_C
;
11032 digest
[3] -= MD5M_D
;
11034 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11036 uint salt_len
= input_len
- 32 - 1;
11038 char *salt_buf
= input_buf
+ 32 + 1;
11040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11042 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11044 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11046 salt
->salt_len
= salt_len
;
11048 return (PARSER_OK
);
11051 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11053 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11055 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11057 salt_t
*salt
= hash_buf
->salt
;
11059 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11060 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11061 digest
[2] = hex_to_uint (&input_buf
[16]);
11062 digest
[3] = hex_to_uint (&input_buf
[24]);
11064 digest
[0] = byte_swap_32 (digest
[0]);
11065 digest
[1] = byte_swap_32 (digest
[1]);
11066 digest
[2] = byte_swap_32 (digest
[2]);
11067 digest
[3] = byte_swap_32 (digest
[3]);
11069 digest
[0] -= MD5M_A
;
11070 digest
[1] -= MD5M_B
;
11071 digest
[2] -= MD5M_C
;
11072 digest
[3] -= MD5M_D
;
11075 * This is a virtual salt. While the algorithm is basically not salted
11076 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11077 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11080 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11082 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11084 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11086 salt
->salt_len
= salt_len
;
11088 return (PARSER_OK
);
11091 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11093 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11095 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11099 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11102 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11104 salt_t
*salt
= hash_buf
->salt
;
11106 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11107 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11108 digest
[2] = hex_to_uint (&input_buf
[16]);
11109 digest
[3] = hex_to_uint (&input_buf
[24]);
11111 digest
[0] = byte_swap_32 (digest
[0]);
11112 digest
[1] = byte_swap_32 (digest
[1]);
11113 digest
[2] = byte_swap_32 (digest
[2]);
11114 digest
[3] = byte_swap_32 (digest
[3]);
11116 digest
[0] -= MD5M_A
;
11117 digest
[1] -= MD5M_B
;
11118 digest
[2] -= MD5M_C
;
11119 digest
[3] -= MD5M_D
;
11121 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11123 uint salt_len
= input_len
- 32 - 1;
11125 char *salt_buf
= input_buf
+ 32 + 1;
11127 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11129 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11131 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11133 salt
->salt_len
= salt_len
;
11135 return (PARSER_OK
);
11138 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11140 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11142 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11146 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11149 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11151 salt_t
*salt
= hash_buf
->salt
;
11153 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11154 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11155 digest
[2] = hex_to_uint (&input_buf
[16]);
11156 digest
[3] = hex_to_uint (&input_buf
[24]);
11158 digest
[0] = byte_swap_32 (digest
[0]);
11159 digest
[1] = byte_swap_32 (digest
[1]);
11160 digest
[2] = byte_swap_32 (digest
[2]);
11161 digest
[3] = byte_swap_32 (digest
[3]);
11163 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11165 uint salt_len
= input_len
- 32 - 1;
11167 char *salt_buf
= input_buf
+ 32 + 1;
11169 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11171 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11173 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11175 salt
->salt_len
= salt_len
;
11177 return (PARSER_OK
);
11180 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11182 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11184 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11188 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11191 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11193 salt_t
*salt
= hash_buf
->salt
;
11195 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11196 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11197 digest
[2] = hex_to_uint (&input_buf
[16]);
11198 digest
[3] = hex_to_uint (&input_buf
[24]);
11200 digest
[0] = byte_swap_32 (digest
[0]);
11201 digest
[1] = byte_swap_32 (digest
[1]);
11202 digest
[2] = byte_swap_32 (digest
[2]);
11203 digest
[3] = byte_swap_32 (digest
[3]);
11205 digest
[0] -= MD4M_A
;
11206 digest
[1] -= MD4M_B
;
11207 digest
[2] -= MD4M_C
;
11208 digest
[3] -= MD4M_D
;
11210 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11212 uint salt_len
= input_len
- 32 - 1;
11214 char *salt_buf
= input_buf
+ 32 + 1;
11216 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11218 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11220 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11222 salt
->salt_len
= salt_len
;
11224 return (PARSER_OK
);
11227 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11229 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11231 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11235 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11238 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11240 salt_t
*salt
= hash_buf
->salt
;
11242 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11243 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11244 digest
[2] = hex_to_uint (&input_buf
[16]);
11245 digest
[3] = hex_to_uint (&input_buf
[24]);
11247 digest
[0] = byte_swap_32 (digest
[0]);
11248 digest
[1] = byte_swap_32 (digest
[1]);
11249 digest
[2] = byte_swap_32 (digest
[2]);
11250 digest
[3] = byte_swap_32 (digest
[3]);
11252 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11254 uint salt_len
= input_len
- 32 - 1;
11256 char *salt_buf
= input_buf
+ 32 + 1;
11258 uint salt_pc_block
[16];
11260 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11262 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11264 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11266 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11268 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11270 salt_pc_block
[14] = salt_len
* 8;
11272 uint salt_pc_digest
[4];
11274 salt_pc_digest
[0] = MAGIC_A
;
11275 salt_pc_digest
[1] = MAGIC_B
;
11276 salt_pc_digest
[2] = MAGIC_C
;
11277 salt_pc_digest
[3] = MAGIC_D
;
11279 md5_64 (salt_pc_block
, salt_pc_digest
);
11281 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11282 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11283 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11284 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11286 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11288 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11290 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11292 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11293 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11294 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11295 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11297 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11299 return (PARSER_OK
);
11302 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11304 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11306 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11308 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11309 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11310 digest
[2] = hex_to_uint (&input_buf
[16]);
11311 digest
[3] = hex_to_uint (&input_buf
[24]);
11312 digest
[4] = hex_to_uint (&input_buf
[32]);
11314 digest
[0] -= SHA1M_A
;
11315 digest
[1] -= SHA1M_B
;
11316 digest
[2] -= SHA1M_C
;
11317 digest
[3] -= SHA1M_D
;
11318 digest
[4] -= SHA1M_E
;
11320 return (PARSER_OK
);
11323 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11325 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11327 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11329 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11330 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11331 digest
[2] = hex_to_uint (&input_buf
[16]);
11332 digest
[3] = hex_to_uint (&input_buf
[24]);
11333 digest
[4] = hex_to_uint (&input_buf
[32]);
11335 return (PARSER_OK
);
11338 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11340 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11342 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11346 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11349 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11351 salt_t
*salt
= hash_buf
->salt
;
11353 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11354 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11355 digest
[2] = hex_to_uint (&input_buf
[16]);
11356 digest
[3] = hex_to_uint (&input_buf
[24]);
11357 digest
[4] = hex_to_uint (&input_buf
[32]);
11359 digest
[0] -= SHA1M_A
;
11360 digest
[1] -= SHA1M_B
;
11361 digest
[2] -= SHA1M_C
;
11362 digest
[3] -= SHA1M_D
;
11363 digest
[4] -= SHA1M_E
;
11365 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11367 uint salt_len
= input_len
- 40 - 1;
11369 char *salt_buf
= input_buf
+ 40 + 1;
11371 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11373 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11375 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11377 salt
->salt_len
= salt_len
;
11379 return (PARSER_OK
);
11382 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11384 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11386 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11388 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11392 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11394 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11396 memcpy (digest
, tmp_buf
, 20);
11398 digest
[0] = byte_swap_32 (digest
[0]);
11399 digest
[1] = byte_swap_32 (digest
[1]);
11400 digest
[2] = byte_swap_32 (digest
[2]);
11401 digest
[3] = byte_swap_32 (digest
[3]);
11402 digest
[4] = byte_swap_32 (digest
[4]);
11404 digest
[0] -= SHA1M_A
;
11405 digest
[1] -= SHA1M_B
;
11406 digest
[2] -= SHA1M_C
;
11407 digest
[3] -= SHA1M_D
;
11408 digest
[4] -= SHA1M_E
;
11410 return (PARSER_OK
);
11413 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11415 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11417 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11419 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11421 salt_t
*salt
= hash_buf
->salt
;
11425 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11427 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11429 memcpy (digest
, tmp_buf
, 20);
11431 salt
->salt_len
= tmp_len
- 20;
11433 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11435 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11437 char *ptr
= (char *) salt
->salt_buf
;
11439 ptr
[salt
->salt_len
] = 0x80;
11442 digest
[0] = byte_swap_32 (digest
[0]);
11443 digest
[1] = byte_swap_32 (digest
[1]);
11444 digest
[2] = byte_swap_32 (digest
[2]);
11445 digest
[3] = byte_swap_32 (digest
[3]);
11446 digest
[4] = byte_swap_32 (digest
[4]);
11448 digest
[0] -= SHA1M_A
;
11449 digest
[1] -= SHA1M_B
;
11450 digest
[2] -= SHA1M_C
;
11451 digest
[3] -= SHA1M_D
;
11452 digest
[4] -= SHA1M_E
;
11454 return (PARSER_OK
);
11457 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11459 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11461 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11463 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11465 salt_t
*salt
= hash_buf
->salt
;
11467 char *salt_buf
= input_buf
+ 6;
11471 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11473 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11475 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11477 salt
->salt_len
= salt_len
;
11479 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11481 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11482 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11483 digest
[2] = hex_to_uint (&hash_pos
[16]);
11484 digest
[3] = hex_to_uint (&hash_pos
[24]);
11485 digest
[4] = hex_to_uint (&hash_pos
[32]);
11487 digest
[0] -= SHA1M_A
;
11488 digest
[1] -= SHA1M_B
;
11489 digest
[2] -= SHA1M_C
;
11490 digest
[3] -= SHA1M_D
;
11491 digest
[4] -= SHA1M_E
;
11493 return (PARSER_OK
);
11496 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11498 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11500 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11502 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11504 salt_t
*salt
= hash_buf
->salt
;
11506 char *salt_buf
= input_buf
+ 6;
11510 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11512 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11514 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11516 salt
->salt_len
= salt_len
;
11518 char *hash_pos
= input_buf
+ 6 + 8;
11520 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11521 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11522 digest
[2] = hex_to_uint (&hash_pos
[16]);
11523 digest
[3] = hex_to_uint (&hash_pos
[24]);
11524 digest
[4] = hex_to_uint (&hash_pos
[32]);
11526 digest
[0] -= SHA1M_A
;
11527 digest
[1] -= SHA1M_B
;
11528 digest
[2] -= SHA1M_C
;
11529 digest
[3] -= SHA1M_D
;
11530 digest
[4] -= SHA1M_E
;
11532 return (PARSER_OK
);
11535 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11537 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11539 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11541 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11543 salt_t
*salt
= hash_buf
->salt
;
11545 char *salt_buf
= input_buf
+ 6;
11549 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11551 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11553 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11555 salt
->salt_len
= salt_len
;
11557 char *hash_pos
= input_buf
+ 6 + 8;
11559 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11560 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11561 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11562 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11563 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11564 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11565 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11566 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11568 digest
[0] -= SHA512M_A
;
11569 digest
[1] -= SHA512M_B
;
11570 digest
[2] -= SHA512M_C
;
11571 digest
[3] -= SHA512M_D
;
11572 digest
[4] -= SHA512M_E
;
11573 digest
[5] -= SHA512M_F
;
11574 digest
[6] -= SHA512M_G
;
11575 digest
[7] -= SHA512M_H
;
11577 return (PARSER_OK
);
11580 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11582 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11584 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11588 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11591 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11593 salt_t
*salt
= hash_buf
->salt
;
11595 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11596 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11600 digest
[0] = byte_swap_32 (digest
[0]);
11601 digest
[1] = byte_swap_32 (digest
[1]);
11603 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11605 uint salt_len
= input_len
- 16 - 1;
11607 char *salt_buf
= input_buf
+ 16 + 1;
11609 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11611 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11613 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11615 salt
->salt_len
= salt_len
;
11617 return (PARSER_OK
);
11620 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11622 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11624 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11626 salt_t
*salt
= hash_buf
->salt
;
11628 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11629 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11630 digest
[2] = hex_to_uint (&input_buf
[16]);
11631 digest
[3] = hex_to_uint (&input_buf
[24]);
11632 digest
[4] = hex_to_uint (&input_buf
[32]);
11634 digest
[0] -= SHA1M_A
;
11635 digest
[1] -= SHA1M_B
;
11636 digest
[2] -= SHA1M_C
;
11637 digest
[3] -= SHA1M_D
;
11638 digest
[4] -= SHA1M_E
;
11640 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11642 uint salt_len
= input_len
- 40 - 1;
11644 char *salt_buf
= input_buf
+ 40 + 1;
11646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11652 salt
->salt_len
= salt_len
;
11654 return (PARSER_OK
);
11657 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11659 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11661 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11663 salt_t
*salt
= hash_buf
->salt
;
11665 char *hash_pos
= input_buf
;
11667 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11668 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11669 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11670 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11671 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11672 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11673 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11674 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11675 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11676 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11677 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11678 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11679 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11680 digest
[13] = hex_to_uint (&hash_pos
[104]);
11681 digest
[14] = hex_to_uint (&hash_pos
[112]);
11682 digest
[15] = hex_to_uint (&hash_pos
[120]);
11684 char *salt_pos
= input_buf
+ 128;
11686 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11687 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11688 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11689 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11691 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11692 salt
->salt_len
= 16;
11694 return (PARSER_OK
);
11697 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11699 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11701 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11703 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11704 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11705 digest
[2] = hex_to_uint (&input_buf
[16]);
11706 digest
[3] = hex_to_uint (&input_buf
[24]);
11707 digest
[4] = hex_to_uint (&input_buf
[32]);
11708 digest
[5] = hex_to_uint (&input_buf
[40]);
11709 digest
[6] = hex_to_uint (&input_buf
[48]);
11710 digest
[7] = hex_to_uint (&input_buf
[56]);
11712 digest
[0] -= SHA256M_A
;
11713 digest
[1] -= SHA256M_B
;
11714 digest
[2] -= SHA256M_C
;
11715 digest
[3] -= SHA256M_D
;
11716 digest
[4] -= SHA256M_E
;
11717 digest
[5] -= SHA256M_F
;
11718 digest
[6] -= SHA256M_G
;
11719 digest
[7] -= SHA256M_H
;
11721 return (PARSER_OK
);
11724 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11726 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11728 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11732 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11735 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11737 salt_t
*salt
= hash_buf
->salt
;
11739 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11740 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11741 digest
[2] = hex_to_uint (&input_buf
[16]);
11742 digest
[3] = hex_to_uint (&input_buf
[24]);
11743 digest
[4] = hex_to_uint (&input_buf
[32]);
11744 digest
[5] = hex_to_uint (&input_buf
[40]);
11745 digest
[6] = hex_to_uint (&input_buf
[48]);
11746 digest
[7] = hex_to_uint (&input_buf
[56]);
11748 digest
[0] -= SHA256M_A
;
11749 digest
[1] -= SHA256M_B
;
11750 digest
[2] -= SHA256M_C
;
11751 digest
[3] -= SHA256M_D
;
11752 digest
[4] -= SHA256M_E
;
11753 digest
[5] -= SHA256M_F
;
11754 digest
[6] -= SHA256M_G
;
11755 digest
[7] -= SHA256M_H
;
11757 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11759 uint salt_len
= input_len
- 64 - 1;
11761 char *salt_buf
= input_buf
+ 64 + 1;
11763 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11765 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11767 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11769 salt
->salt_len
= salt_len
;
11771 return (PARSER_OK
);
11774 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11776 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11778 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11780 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11781 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11782 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11783 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11784 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11785 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11789 digest
[0] -= SHA384M_A
;
11790 digest
[1] -= SHA384M_B
;
11791 digest
[2] -= SHA384M_C
;
11792 digest
[3] -= SHA384M_D
;
11793 digest
[4] -= SHA384M_E
;
11794 digest
[5] -= SHA384M_F
;
11798 return (PARSER_OK
);
11801 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11803 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11805 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11807 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11808 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11809 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11810 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11811 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11812 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11813 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11814 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11816 digest
[0] -= SHA512M_A
;
11817 digest
[1] -= SHA512M_B
;
11818 digest
[2] -= SHA512M_C
;
11819 digest
[3] -= SHA512M_D
;
11820 digest
[4] -= SHA512M_E
;
11821 digest
[5] -= SHA512M_F
;
11822 digest
[6] -= SHA512M_G
;
11823 digest
[7] -= SHA512M_H
;
11825 return (PARSER_OK
);
11828 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11830 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11832 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11836 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11839 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11841 salt_t
*salt
= hash_buf
->salt
;
11843 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11844 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11845 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11846 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11847 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11848 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11849 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11850 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11852 digest
[0] -= SHA512M_A
;
11853 digest
[1] -= SHA512M_B
;
11854 digest
[2] -= SHA512M_C
;
11855 digest
[3] -= SHA512M_D
;
11856 digest
[4] -= SHA512M_E
;
11857 digest
[5] -= SHA512M_F
;
11858 digest
[6] -= SHA512M_G
;
11859 digest
[7] -= SHA512M_H
;
11861 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11863 uint salt_len
= input_len
- 128 - 1;
11865 char *salt_buf
= input_buf
+ 128 + 1;
11867 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11869 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11871 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11873 salt
->salt_len
= salt_len
;
11875 return (PARSER_OK
);
11878 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11880 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11882 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11884 salt_t
*salt
= hash_buf
->salt
;
11886 char *salt_pos
= input_buf
+ 3;
11888 uint iterations_len
= 0;
11890 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11894 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11896 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11897 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11901 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11905 iterations_len
+= 8;
11909 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11912 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11914 char *hash_pos
= strchr (salt_pos
, '$');
11916 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11918 uint salt_len
= hash_pos
- salt_pos
;
11920 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11922 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11924 salt
->salt_len
= salt_len
;
11928 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11930 return (PARSER_OK
);
11933 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11935 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11937 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11939 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11941 salt_t
*salt
= hash_buf
->salt
;
11943 uint keccak_mdlen
= input_len
/ 2;
11945 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11947 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11949 digest
[i
] = byte_swap_64 (digest
[i
]);
11952 salt
->keccak_mdlen
= keccak_mdlen
;
11954 return (PARSER_OK
);
11957 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11959 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11961 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11963 salt_t
*salt
= hash_buf
->salt
;
11965 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11968 * Parse that strange long line
11975 in_off
[0] = strtok (input_buf
, ":");
11977 in_len
[0] = strlen (in_off
[0]);
11981 for (i
= 1; i
< 9; i
++)
11983 in_off
[i
] = strtok (NULL
, ":");
11985 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11987 in_len
[i
] = strlen (in_off
[i
]);
11992 ptr
= (char *) ikepsk
->msg_buf
;
11994 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11995 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11996 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11997 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11998 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11999 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12003 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12005 ptr
= (char *) ikepsk
->nr_buf
;
12007 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12008 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12012 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12015 * Store to database
12020 digest
[0] = hex_to_uint (&ptr
[ 0]);
12021 digest
[1] = hex_to_uint (&ptr
[ 8]);
12022 digest
[2] = hex_to_uint (&ptr
[16]);
12023 digest
[3] = hex_to_uint (&ptr
[24]);
12025 digest
[0] = byte_swap_32 (digest
[0]);
12026 digest
[1] = byte_swap_32 (digest
[1]);
12027 digest
[2] = byte_swap_32 (digest
[2]);
12028 digest
[3] = byte_swap_32 (digest
[3]);
12030 salt
->salt_len
= 32;
12032 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12033 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12034 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12035 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12036 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12037 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12038 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12039 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12041 return (PARSER_OK
);
12044 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12046 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12048 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12050 salt_t
*salt
= hash_buf
->salt
;
12052 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12055 * Parse that strange long line
12062 in_off
[0] = strtok (input_buf
, ":");
12064 in_len
[0] = strlen (in_off
[0]);
12068 for (i
= 1; i
< 9; i
++)
12070 in_off
[i
] = strtok (NULL
, ":");
12072 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12074 in_len
[i
] = strlen (in_off
[i
]);
12079 ptr
= (char *) ikepsk
->msg_buf
;
12081 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12082 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12083 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12084 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12085 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12086 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12090 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12092 ptr
= (char *) ikepsk
->nr_buf
;
12094 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12095 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12099 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12102 * Store to database
12107 digest
[0] = hex_to_uint (&ptr
[ 0]);
12108 digest
[1] = hex_to_uint (&ptr
[ 8]);
12109 digest
[2] = hex_to_uint (&ptr
[16]);
12110 digest
[3] = hex_to_uint (&ptr
[24]);
12111 digest
[4] = hex_to_uint (&ptr
[32]);
12113 salt
->salt_len
= 32;
12115 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12116 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12117 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12118 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12119 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12120 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12121 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12122 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12124 return (PARSER_OK
);
12127 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12129 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12131 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12133 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12134 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12135 digest
[2] = hex_to_uint (&input_buf
[16]);
12136 digest
[3] = hex_to_uint (&input_buf
[24]);
12137 digest
[4] = hex_to_uint (&input_buf
[32]);
12139 digest
[0] = byte_swap_32 (digest
[0]);
12140 digest
[1] = byte_swap_32 (digest
[1]);
12141 digest
[2] = byte_swap_32 (digest
[2]);
12142 digest
[3] = byte_swap_32 (digest
[3]);
12143 digest
[4] = byte_swap_32 (digest
[4]);
12145 return (PARSER_OK
);
12148 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12150 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12152 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12154 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12155 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12156 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12157 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12158 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12159 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12160 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12161 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12162 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12163 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12164 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12165 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12166 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12167 digest
[13] = hex_to_uint (&input_buf
[104]);
12168 digest
[14] = hex_to_uint (&input_buf
[112]);
12169 digest
[15] = hex_to_uint (&input_buf
[120]);
12171 return (PARSER_OK
);
12174 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12176 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12178 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12180 salt_t
*salt
= hash_buf
->salt
;
12182 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12183 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12184 digest
[2] = hex_to_uint (&input_buf
[16]);
12185 digest
[3] = hex_to_uint (&input_buf
[24]);
12186 digest
[4] = hex_to_uint (&input_buf
[32]);
12188 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12190 uint salt_len
= input_len
- 40 - 1;
12192 char *salt_buf
= input_buf
+ 40 + 1;
12194 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12196 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12198 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12200 salt
->salt_len
= salt_len
;
12202 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12204 return (PARSER_OK
);
12207 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12209 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12211 salt_t
*salt
= hash_buf
->salt
;
12213 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12215 if (input_len
== 0)
12217 log_error ("TrueCrypt container not specified");
12222 FILE *fp
= fopen (input_buf
, "rb");
12226 log_error ("%s: %s", input_buf
, strerror (errno
));
12233 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12237 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12239 memcpy (tc
->salt_buf
, buf
, 64);
12241 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12243 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12245 salt
->salt_len
= 4;
12247 salt
->salt_iter
= 1000 - 1;
12249 digest
[0] = tc
->data_buf
[0];
12251 return (PARSER_OK
);
12254 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12256 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12258 salt_t
*salt
= hash_buf
->salt
;
12260 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12262 if (input_len
== 0)
12264 log_error ("TrueCrypt container not specified");
12269 FILE *fp
= fopen (input_buf
, "rb");
12273 log_error ("%s: %s", input_buf
, strerror (errno
));
12280 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12284 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12286 memcpy (tc
->salt_buf
, buf
, 64);
12288 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12290 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12292 salt
->salt_len
= 4;
12294 salt
->salt_iter
= 2000 - 1;
12296 digest
[0] = tc
->data_buf
[0];
12298 return (PARSER_OK
);
12301 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12303 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12305 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12307 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12309 salt_t
*salt
= hash_buf
->salt
;
12311 char *salt_pos
= input_buf
+ 6;
12313 char *hash_pos
= strchr (salt_pos
, '$');
12315 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12317 uint salt_len
= hash_pos
- salt_pos
;
12319 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12321 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12323 salt
->salt_len
= salt_len
;
12325 salt
->salt_iter
= 1000;
12329 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12331 return (PARSER_OK
);
12334 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12336 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12338 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12340 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12342 salt_t
*salt
= hash_buf
->salt
;
12344 char *iter_pos
= input_buf
+ 7;
12346 char *salt_pos
= strchr (iter_pos
, '$');
12348 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12352 char *hash_pos
= strchr (salt_pos
, '$');
12354 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12356 uint salt_len
= hash_pos
- salt_pos
;
12358 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12360 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12362 salt
->salt_len
= salt_len
;
12364 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12366 salt
->salt_sign
[0] = atoi (salt_iter
);
12368 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12372 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12374 digest
[0] = byte_swap_32 (digest
[0]);
12375 digest
[1] = byte_swap_32 (digest
[1]);
12376 digest
[2] = byte_swap_32 (digest
[2]);
12377 digest
[3] = byte_swap_32 (digest
[3]);
12378 digest
[4] = byte_swap_32 (digest
[4]);
12380 return (PARSER_OK
);
12383 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12385 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12387 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12389 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12391 salt_t
*salt
= hash_buf
->salt
;
12393 char *iter_pos
= input_buf
+ 9;
12395 char *salt_pos
= strchr (iter_pos
, '$');
12397 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12401 char *hash_pos
= strchr (salt_pos
, '$');
12403 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12405 uint salt_len
= hash_pos
- salt_pos
;
12407 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12409 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12411 salt
->salt_len
= salt_len
;
12413 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12415 salt
->salt_sign
[0] = atoi (salt_iter
);
12417 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12421 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12423 digest
[0] = byte_swap_32 (digest
[0]);
12424 digest
[1] = byte_swap_32 (digest
[1]);
12425 digest
[2] = byte_swap_32 (digest
[2]);
12426 digest
[3] = byte_swap_32 (digest
[3]);
12427 digest
[4] = byte_swap_32 (digest
[4]);
12428 digest
[5] = byte_swap_32 (digest
[5]);
12429 digest
[6] = byte_swap_32 (digest
[6]);
12430 digest
[7] = byte_swap_32 (digest
[7]);
12432 return (PARSER_OK
);
12435 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12437 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12439 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12441 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12443 salt_t
*salt
= hash_buf
->salt
;
12445 char *iter_pos
= input_buf
+ 9;
12447 char *salt_pos
= strchr (iter_pos
, '$');
12449 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12453 char *hash_pos
= strchr (salt_pos
, '$');
12455 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12457 uint salt_len
= hash_pos
- salt_pos
;
12459 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12461 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12463 salt
->salt_len
= salt_len
;
12465 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12467 salt
->salt_sign
[0] = atoi (salt_iter
);
12469 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12473 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12475 digest
[0] = byte_swap_64 (digest
[0]);
12476 digest
[1] = byte_swap_64 (digest
[1]);
12477 digest
[2] = byte_swap_64 (digest
[2]);
12478 digest
[3] = byte_swap_64 (digest
[3]);
12479 digest
[4] = byte_swap_64 (digest
[4]);
12480 digest
[5] = byte_swap_64 (digest
[5]);
12481 digest
[6] = byte_swap_64 (digest
[6]);
12482 digest
[7] = byte_swap_64 (digest
[7]);
12484 return (PARSER_OK
);
12487 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12489 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12491 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12493 salt_t
*salt
= hash_buf
->salt
;
12495 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12501 char *iterations_pos
= input_buf
;
12503 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12505 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12507 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12509 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12513 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12515 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12517 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12519 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12521 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12523 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12528 * pbkdf2 iterations
12531 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12534 * handle salt encoding
12537 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12539 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12541 const char p0
= saltbuf_pos
[i
+ 0];
12542 const char p1
= saltbuf_pos
[i
+ 1];
12544 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12545 | hex_convert (p0
) << 4;
12548 salt
->salt_len
= saltbuf_len
/ 2;
12551 * handle cipher encoding
12554 uint
*tmp
= (uint
*) mymalloc (32);
12556 char *cipherbuf_ptr
= (char *) tmp
;
12558 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12560 const char p0
= cipherbuf_pos
[i
+ 0];
12561 const char p1
= cipherbuf_pos
[i
+ 1];
12563 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12564 | hex_convert (p0
) << 4;
12567 // iv is stored at salt_buf 4 (length 16)
12568 // data is stored at salt_buf 8 (length 16)
12570 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12571 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12572 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12573 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12575 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12576 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12577 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12578 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12582 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12584 const char p0
= cipherbuf_pos
[j
+ 0];
12585 const char p1
= cipherbuf_pos
[j
+ 1];
12587 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12588 | hex_convert (p0
) << 4;
12595 digest
[0] = 0x10101010;
12596 digest
[1] = 0x10101010;
12597 digest
[2] = 0x10101010;
12598 digest
[3] = 0x10101010;
12600 return (PARSER_OK
);
12603 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12605 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12607 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12609 salt_t
*salt
= hash_buf
->salt
;
12611 char *hashbuf_pos
= input_buf
;
12613 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12615 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12617 uint hash_len
= iterations_pos
- hashbuf_pos
;
12619 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12623 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12625 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12627 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12631 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12633 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12635 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12637 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12639 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12641 salt
->salt_len
= salt_len
;
12643 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12645 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12646 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12647 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12648 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12650 return (PARSER_OK
);
12653 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12655 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12657 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12659 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12660 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12661 digest
[2] = hex_to_uint (&input_buf
[16]);
12662 digest
[3] = hex_to_uint (&input_buf
[24]);
12663 digest
[4] = hex_to_uint (&input_buf
[32]);
12664 digest
[5] = hex_to_uint (&input_buf
[40]);
12665 digest
[6] = hex_to_uint (&input_buf
[48]);
12666 digest
[7] = hex_to_uint (&input_buf
[56]);
12668 digest
[0] = byte_swap_32 (digest
[0]);
12669 digest
[1] = byte_swap_32 (digest
[1]);
12670 digest
[2] = byte_swap_32 (digest
[2]);
12671 digest
[3] = byte_swap_32 (digest
[3]);
12672 digest
[4] = byte_swap_32 (digest
[4]);
12673 digest
[5] = byte_swap_32 (digest
[5]);
12674 digest
[6] = byte_swap_32 (digest
[6]);
12675 digest
[7] = byte_swap_32 (digest
[7]);
12677 return (PARSER_OK
);
12680 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12682 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12684 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12686 salt_t
*salt
= hash_buf
->salt
;
12688 char *salt_pos
= input_buf
+ 3;
12690 uint iterations_len
= 0;
12692 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12696 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12698 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12699 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12703 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12707 iterations_len
+= 8;
12711 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12714 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12716 char *hash_pos
= strchr (salt_pos
, '$');
12718 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12720 uint salt_len
= hash_pos
- salt_pos
;
12722 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12724 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12726 salt
->salt_len
= salt_len
;
12730 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12732 return (PARSER_OK
);
12735 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12737 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12739 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12741 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12743 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12745 salt_t
*salt
= hash_buf
->salt
;
12747 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12749 char *iter_pos
= input_buf
+ 4;
12751 char *salt_pos
= strchr (iter_pos
, '$');
12753 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12757 char *hash_pos
= strchr (salt_pos
, '$');
12759 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12761 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12765 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12766 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12767 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12768 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12769 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12770 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12771 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12772 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12774 uint salt_len
= hash_pos
- salt_pos
- 1;
12776 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12778 salt
->salt_len
= salt_len
/ 2;
12780 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12781 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12782 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12783 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12784 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12785 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12786 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12787 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12789 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12790 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12791 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12792 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12793 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12794 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12795 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12796 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12797 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12798 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12800 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12802 salt
->salt_iter
= atoi (iter_pos
) - 1;
12804 return (PARSER_OK
);
12807 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12809 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12811 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12813 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12815 salt_t
*salt
= hash_buf
->salt
;
12817 char *salt_pos
= input_buf
+ 14;
12819 char *hash_pos
= strchr (salt_pos
, '*');
12821 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12825 uint salt_len
= hash_pos
- salt_pos
- 1;
12827 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12829 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12831 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12833 salt
->salt_len
= salt_len
;
12835 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12837 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12839 memcpy (digest
, tmp_buf
, 32);
12841 digest
[0] = byte_swap_32 (digest
[0]);
12842 digest
[1] = byte_swap_32 (digest
[1]);
12843 digest
[2] = byte_swap_32 (digest
[2]);
12844 digest
[3] = byte_swap_32 (digest
[3]);
12845 digest
[4] = byte_swap_32 (digest
[4]);
12846 digest
[5] = byte_swap_32 (digest
[5]);
12847 digest
[6] = byte_swap_32 (digest
[6]);
12848 digest
[7] = byte_swap_32 (digest
[7]);
12850 digest
[0] -= SHA256M_A
;
12851 digest
[1] -= SHA256M_B
;
12852 digest
[2] -= SHA256M_C
;
12853 digest
[3] -= SHA256M_D
;
12854 digest
[4] -= SHA256M_E
;
12855 digest
[5] -= SHA256M_F
;
12856 digest
[6] -= SHA256M_G
;
12857 digest
[7] -= SHA256M_H
;
12859 return (PARSER_OK
);
12862 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12864 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12866 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12868 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12870 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12872 salt_t
*salt
= hash_buf
->salt
;
12874 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12876 char *iter_pos
= input_buf
+ 19;
12878 char *salt_pos
= strchr (iter_pos
, '.');
12880 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12884 char *hash_pos
= strchr (salt_pos
, '.');
12886 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12888 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12892 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12893 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12894 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12895 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12896 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12897 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12898 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12899 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12901 uint salt_len
= hash_pos
- salt_pos
- 1;
12905 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12909 for (i
= 0; i
< salt_len
; i
++)
12911 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12914 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12915 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12917 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12919 salt
->salt_len
= salt_len
;
12921 salt
->salt_iter
= atoi (iter_pos
) - 1;
12923 return (PARSER_OK
);
12926 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12928 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12930 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12932 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12934 salt_t
*salt
= hash_buf
->salt
;
12938 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12940 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12942 memcpy (digest
, tmp_buf
, 64);
12944 digest
[0] = byte_swap_64 (digest
[0]);
12945 digest
[1] = byte_swap_64 (digest
[1]);
12946 digest
[2] = byte_swap_64 (digest
[2]);
12947 digest
[3] = byte_swap_64 (digest
[3]);
12948 digest
[4] = byte_swap_64 (digest
[4]);
12949 digest
[5] = byte_swap_64 (digest
[5]);
12950 digest
[6] = byte_swap_64 (digest
[6]);
12951 digest
[7] = byte_swap_64 (digest
[7]);
12953 digest
[0] -= SHA512M_A
;
12954 digest
[1] -= SHA512M_B
;
12955 digest
[2] -= SHA512M_C
;
12956 digest
[3] -= SHA512M_D
;
12957 digest
[4] -= SHA512M_E
;
12958 digest
[5] -= SHA512M_F
;
12959 digest
[6] -= SHA512M_G
;
12960 digest
[7] -= SHA512M_H
;
12962 salt
->salt_len
= tmp_len
- 64;
12964 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12966 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12968 char *ptr
= (char *) salt
->salt_buf
;
12970 ptr
[salt
->salt_len
] = 0x80;
12973 return (PARSER_OK
);
12976 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12978 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12980 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12984 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12987 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12989 salt_t
*salt
= hash_buf
->salt
;
12991 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12992 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12993 digest
[2] = hex_to_uint (&input_buf
[16]);
12994 digest
[3] = hex_to_uint (&input_buf
[24]);
12996 digest
[0] = byte_swap_32 (digest
[0]);
12997 digest
[1] = byte_swap_32 (digest
[1]);
12998 digest
[2] = byte_swap_32 (digest
[2]);
12999 digest
[3] = byte_swap_32 (digest
[3]);
13001 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13003 uint salt_len
= input_len
- 32 - 1;
13005 char *salt_buf
= input_buf
+ 32 + 1;
13007 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13009 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13011 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13013 salt
->salt_len
= salt_len
;
13015 return (PARSER_OK
);
13018 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13020 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13022 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13026 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13029 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13031 salt_t
*salt
= hash_buf
->salt
;
13033 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13034 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13035 digest
[2] = hex_to_uint (&input_buf
[16]);
13036 digest
[3] = hex_to_uint (&input_buf
[24]);
13037 digest
[4] = hex_to_uint (&input_buf
[32]);
13039 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13041 uint salt_len
= input_len
- 40 - 1;
13043 char *salt_buf
= input_buf
+ 40 + 1;
13045 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13047 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13049 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13051 salt
->salt_len
= salt_len
;
13053 return (PARSER_OK
);
13056 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13058 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13060 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13064 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13067 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13069 salt_t
*salt
= hash_buf
->salt
;
13071 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13072 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13073 digest
[2] = hex_to_uint (&input_buf
[16]);
13074 digest
[3] = hex_to_uint (&input_buf
[24]);
13075 digest
[4] = hex_to_uint (&input_buf
[32]);
13076 digest
[5] = hex_to_uint (&input_buf
[40]);
13077 digest
[6] = hex_to_uint (&input_buf
[48]);
13078 digest
[7] = hex_to_uint (&input_buf
[56]);
13080 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13082 uint salt_len
= input_len
- 64 - 1;
13084 char *salt_buf
= input_buf
+ 64 + 1;
13086 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13088 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13090 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13092 salt
->salt_len
= salt_len
;
13094 return (PARSER_OK
);
13097 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13099 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13101 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13105 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13108 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13110 salt_t
*salt
= hash_buf
->salt
;
13112 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13113 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13114 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13115 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13116 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13117 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13118 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13119 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13121 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13123 uint salt_len
= input_len
- 128 - 1;
13125 char *salt_buf
= input_buf
+ 128 + 1;
13127 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13129 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13131 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13133 salt
->salt_len
= salt_len
;
13135 return (PARSER_OK
);
13138 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13140 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13142 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13144 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13146 salt_t
*salt
= hash_buf
->salt
;
13148 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13154 char *user_pos
= input_buf
+ 10 + 1;
13156 char *realm_pos
= strchr (user_pos
, '$');
13158 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13160 uint user_len
= realm_pos
- user_pos
;
13162 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13166 char *salt_pos
= strchr (realm_pos
, '$');
13168 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13170 uint realm_len
= salt_pos
- realm_pos
;
13172 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13176 char *data_pos
= strchr (salt_pos
, '$');
13178 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13180 uint salt_len
= data_pos
- salt_pos
;
13182 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13186 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13188 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13194 memcpy (krb5pa
->user
, user_pos
, user_len
);
13195 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13196 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13198 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13200 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13202 const char p0
= data_pos
[i
+ 0];
13203 const char p1
= data_pos
[i
+ 1];
13205 *timestamp_ptr
++ = hex_convert (p1
) << 0
13206 | hex_convert (p0
) << 4;
13209 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13211 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13213 const char p0
= data_pos
[i
+ 0];
13214 const char p1
= data_pos
[i
+ 1];
13216 *checksum_ptr
++ = hex_convert (p1
) << 0
13217 | hex_convert (p0
) << 4;
13221 * copy some data to generic buffers to make sorting happy
13224 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13225 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13226 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13227 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13228 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13229 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13230 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13231 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13232 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13234 salt
->salt_len
= 36;
13236 digest
[0] = krb5pa
->checksum
[0];
13237 digest
[1] = krb5pa
->checksum
[1];
13238 digest
[2] = krb5pa
->checksum
[2];
13239 digest
[3] = krb5pa
->checksum
[3];
13241 return (PARSER_OK
);
13244 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13246 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13248 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13250 salt_t
*salt
= hash_buf
->salt
;
13256 char *salt_pos
= input_buf
;
13258 char *hash_pos
= strchr (salt_pos
, '$');
13260 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13262 uint salt_len
= hash_pos
- salt_pos
;
13264 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13268 uint hash_len
= input_len
- 1 - salt_len
;
13270 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13278 for (uint i
= 0; i
< salt_len
; i
++)
13280 if (salt_pos
[i
] == ' ') continue;
13285 // SAP user names cannot be longer than 12 characters
13286 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13288 // SAP user name cannot start with ! or ?
13289 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13295 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13297 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13299 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13301 salt
->salt_len
= salt_len
;
13303 digest
[0] = hex_to_uint (&hash_pos
[0]);
13304 digest
[1] = hex_to_uint (&hash_pos
[8]);
13308 digest
[0] = byte_swap_32 (digest
[0]);
13309 digest
[1] = byte_swap_32 (digest
[1]);
13311 return (PARSER_OK
);
13314 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13316 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13318 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13320 salt_t
*salt
= hash_buf
->salt
;
13326 char *salt_pos
= input_buf
;
13328 char *hash_pos
= strchr (salt_pos
, '$');
13330 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13332 uint salt_len
= hash_pos
- salt_pos
;
13334 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13338 uint hash_len
= input_len
- 1 - salt_len
;
13340 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13348 for (uint i
= 0; i
< salt_len
; i
++)
13350 if (salt_pos
[i
] == ' ') continue;
13355 // SAP user names cannot be longer than 12 characters
13356 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13357 // so far nobody complained so we stay with this because it helps in optimization
13358 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13360 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13362 // SAP user name cannot start with ! or ?
13363 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13369 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13371 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13373 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13375 salt
->salt_len
= salt_len
;
13377 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13378 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13379 digest
[2] = hex_to_uint (&hash_pos
[16]);
13380 digest
[3] = hex_to_uint (&hash_pos
[24]);
13381 digest
[4] = hex_to_uint (&hash_pos
[32]);
13383 return (PARSER_OK
);
13386 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13388 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13390 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13392 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13394 salt_t
*salt
= hash_buf
->salt
;
13396 char *iter_pos
= input_buf
+ 3;
13398 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13400 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13402 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13404 salt
->salt_iter
= salt_iter
;
13406 char *salt_pos
= iter_pos
+ 1;
13410 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13412 salt
->salt_len
= salt_len
;
13414 char *hash_pos
= salt_pos
+ salt_len
;
13416 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13420 char *tmp
= (char *) salt
->salt_buf_pc
;
13422 tmp
[0] = hash_pos
[42];
13426 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13427 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13428 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13429 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13435 return (PARSER_OK
);
13438 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13440 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13442 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13444 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13446 salt_t
*salt
= hash_buf
->salt
;
13448 char *salt_buf
= input_buf
+ 6;
13450 uint salt_len
= 16;
13452 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13454 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13456 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13458 salt
->salt_len
= salt_len
;
13460 char *hash_pos
= input_buf
+ 6 + 16;
13462 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13463 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13464 digest
[2] = hex_to_uint (&hash_pos
[16]);
13465 digest
[3] = hex_to_uint (&hash_pos
[24]);
13466 digest
[4] = hex_to_uint (&hash_pos
[32]);
13467 digest
[5] = hex_to_uint (&hash_pos
[40]);
13468 digest
[6] = hex_to_uint (&hash_pos
[48]);
13469 digest
[7] = hex_to_uint (&hash_pos
[56]);
13471 return (PARSER_OK
);
13474 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13476 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13478 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13480 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13481 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13485 return (PARSER_OK
);
13488 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13490 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13492 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13494 salt_t
*salt
= hash_buf
->salt
;
13496 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13498 char *saltbuf_pos
= input_buf
;
13500 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13502 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13504 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13506 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13507 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13509 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13513 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13515 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13517 char *salt_ptr
= (char *) saltbuf_pos
;
13518 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13523 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13525 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13528 rakp_ptr
[j
] = 0x80;
13530 rakp
->salt_len
= j
;
13532 for (i
= 0; i
< 64; i
++)
13534 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13537 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13538 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13539 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13540 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13541 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13542 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13543 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13544 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13546 salt
->salt_len
= 32; // muss min. 32 haben
13548 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13549 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13550 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13551 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13552 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13554 return (PARSER_OK
);
13557 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13559 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13561 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13563 salt_t
*salt
= hash_buf
->salt
;
13565 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13567 char *salt_pos
= input_buf
+ 1;
13569 memcpy (salt
->salt_buf
, salt_pos
, 8);
13571 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13572 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13574 salt
->salt_len
= 8;
13576 char *hash_pos
= salt_pos
+ 8;
13578 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13579 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13580 digest
[2] = hex_to_uint (&hash_pos
[16]);
13581 digest
[3] = hex_to_uint (&hash_pos
[24]);
13582 digest
[4] = hex_to_uint (&hash_pos
[32]);
13584 digest
[0] -= SHA1M_A
;
13585 digest
[1] -= SHA1M_B
;
13586 digest
[2] -= SHA1M_C
;
13587 digest
[3] -= SHA1M_D
;
13588 digest
[4] -= SHA1M_E
;
13590 return (PARSER_OK
);
13593 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13595 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13597 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13599 salt_t
*salt
= hash_buf
->salt
;
13601 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13602 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13603 digest
[2] = hex_to_uint (&input_buf
[16]);
13604 digest
[3] = hex_to_uint (&input_buf
[24]);
13606 digest
[0] = byte_swap_32 (digest
[0]);
13607 digest
[1] = byte_swap_32 (digest
[1]);
13608 digest
[2] = byte_swap_32 (digest
[2]);
13609 digest
[3] = byte_swap_32 (digest
[3]);
13611 digest
[0] -= MD5M_A
;
13612 digest
[1] -= MD5M_B
;
13613 digest
[2] -= MD5M_C
;
13614 digest
[3] -= MD5M_D
;
13616 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13618 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13620 uint32_t *salt_buf
= salt
->salt_buf
;
13622 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13623 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13624 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13625 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13627 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13628 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13629 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13630 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13632 salt
->salt_len
= 16 + 1;
13634 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13636 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13638 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13640 return (PARSER_OK
);
13643 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13645 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13647 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13649 salt_t
*salt
= hash_buf
->salt
;
13651 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13657 char *hashbuf_pos
= input_buf
;
13659 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13661 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13663 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13665 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13669 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13671 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13673 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13675 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13679 char *databuf_pos
= strchr (iteration_pos
, ':');
13681 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13683 const uint iteration_len
= databuf_pos
- iteration_pos
;
13685 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13686 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13688 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13690 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13691 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13697 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13698 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13699 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13700 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13701 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13702 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13703 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13704 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13708 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13710 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13712 const char p0
= saltbuf_pos
[i
+ 0];
13713 const char p1
= saltbuf_pos
[i
+ 1];
13715 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13716 | hex_convert (p0
) << 4;
13719 salt
->salt_buf
[4] = 0x01000000;
13720 salt
->salt_buf
[5] = 0x80;
13722 salt
->salt_len
= saltbuf_len
/ 2;
13726 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13730 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13732 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13734 const char p0
= databuf_pos
[i
+ 0];
13735 const char p1
= databuf_pos
[i
+ 1];
13737 *databuf_ptr
++ = hex_convert (p1
) << 0
13738 | hex_convert (p0
) << 4;
13741 *databuf_ptr
++ = 0x80;
13743 for (uint i
= 0; i
< 512; i
++)
13745 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13748 cloudkey
->data_len
= databuf_len
/ 2;
13750 return (PARSER_OK
);
13753 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13755 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13757 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13759 salt_t
*salt
= hash_buf
->salt
;
13765 char *hashbuf_pos
= input_buf
;
13767 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13769 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13771 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13773 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13777 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13779 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13781 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13783 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13785 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13789 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13791 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13793 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13795 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13797 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13801 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13803 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13804 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13806 // ok, the plan for this algorithm is the following:
13807 // we have 2 salts here, the domain-name and a random salt
13808 // while both are used in the initial transformation,
13809 // only the random salt is used in the following iterations
13810 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13811 // and one that includes only the real salt (stored into salt_buf[]).
13812 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13814 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13816 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13818 memcpy (digest
, tmp_buf
, 20);
13820 digest
[0] = byte_swap_32 (digest
[0]);
13821 digest
[1] = byte_swap_32 (digest
[1]);
13822 digest
[2] = byte_swap_32 (digest
[2]);
13823 digest
[3] = byte_swap_32 (digest
[3]);
13824 digest
[4] = byte_swap_32 (digest
[4]);
13828 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13830 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13832 char *len_ptr
= NULL
;
13834 for (uint i
= 0; i
< domainbuf_len
; i
++)
13836 if (salt_buf_pc_ptr
[i
] == '.')
13838 len_ptr
= &salt_buf_pc_ptr
[i
];
13848 salt
->salt_buf_pc
[7] = domainbuf_len
;
13852 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13854 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13856 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13858 salt
->salt_len
= salt_len
;
13862 salt
->salt_iter
= atoi (iteration_pos
);
13864 return (PARSER_OK
);
13867 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13869 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13871 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13873 salt_t
*salt
= hash_buf
->salt
;
13875 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13876 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13877 digest
[2] = hex_to_uint (&input_buf
[16]);
13878 digest
[3] = hex_to_uint (&input_buf
[24]);
13879 digest
[4] = hex_to_uint (&input_buf
[32]);
13881 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13883 uint salt_len
= input_len
- 40 - 1;
13885 char *salt_buf
= input_buf
+ 40 + 1;
13887 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13889 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13891 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13893 salt
->salt_len
= salt_len
;
13895 return (PARSER_OK
);
13898 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13900 const uint8_t ascii_to_ebcdic
[] =
13902 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13903 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13904 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13905 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13906 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13907 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13908 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13909 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13910 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13911 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13912 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13913 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13914 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13915 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13916 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13917 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13920 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13922 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13924 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13926 salt_t
*salt
= hash_buf
->salt
;
13928 char *salt_pos
= input_buf
+ 6 + 1;
13930 char *digest_pos
= strchr (salt_pos
, '*');
13932 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13934 uint salt_len
= digest_pos
- salt_pos
;
13936 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13938 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13940 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13944 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13945 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13947 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13949 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13951 salt
->salt_len
= salt_len
;
13953 for (uint i
= 0; i
< salt_len
; i
++)
13955 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13957 for (uint i
= salt_len
; i
< 8; i
++)
13959 salt_buf_pc_ptr
[i
] = 0x40;
13964 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13966 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13967 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13969 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13970 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13972 digest
[0] = byte_swap_32 (digest
[0]);
13973 digest
[1] = byte_swap_32 (digest
[1]);
13975 IP (digest
[0], digest
[1], tt
);
13977 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13978 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13982 return (PARSER_OK
);
13985 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13987 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13989 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13991 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13992 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13993 digest
[2] = hex_to_uint (&input_buf
[16]);
13994 digest
[3] = hex_to_uint (&input_buf
[24]);
13996 digest
[0] = byte_swap_32 (digest
[0]);
13997 digest
[1] = byte_swap_32 (digest
[1]);
13998 digest
[2] = byte_swap_32 (digest
[2]);
13999 digest
[3] = byte_swap_32 (digest
[3]);
14001 return (PARSER_OK
);
14004 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14006 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14008 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14010 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14012 salt_t
*salt
= hash_buf
->salt
;
14016 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14018 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14020 tmp_buf
[3] += -4; // dont ask!
14022 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14024 salt
->salt_len
= 5;
14026 memcpy (digest
, tmp_buf
+ 5, 9);
14028 // yes, only 9 byte are needed to crack, but 10 to display
14030 salt
->salt_buf_pc
[7] = input_buf
[20];
14032 return (PARSER_OK
);
14035 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14037 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14039 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14041 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14043 salt_t
*salt
= hash_buf
->salt
;
14047 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14049 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14051 tmp_buf
[3] += -4; // dont ask!
14055 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14057 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)
14061 char tmp_iter_buf
[11];
14063 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14065 tmp_iter_buf
[10] = 0;
14067 salt
->salt_iter
= atoi (tmp_iter_buf
);
14069 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14071 return (PARSER_SALT_ITERATION
);
14074 salt
->salt_iter
--; // first round in init
14076 // 2 additional bytes for display only
14078 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14079 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14083 memcpy (digest
, tmp_buf
+ 28, 8);
14085 digest
[0] = byte_swap_32 (digest
[0]);
14086 digest
[1] = byte_swap_32 (digest
[1]);
14090 return (PARSER_OK
);
14093 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14095 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14097 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14099 salt_t
*salt
= hash_buf
->salt
;
14101 char *salt_buf_pos
= input_buf
;
14103 char *hash_buf_pos
= salt_buf_pos
+ 6;
14105 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14106 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14107 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14108 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14109 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14110 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14111 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14112 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14114 digest
[0] -= SHA256M_A
;
14115 digest
[1] -= SHA256M_B
;
14116 digest
[2] -= SHA256M_C
;
14117 digest
[3] -= SHA256M_D
;
14118 digest
[4] -= SHA256M_E
;
14119 digest
[5] -= SHA256M_F
;
14120 digest
[6] -= SHA256M_G
;
14121 digest
[7] -= SHA256M_H
;
14123 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14125 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14127 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14129 salt
->salt_len
= salt_len
;
14131 return (PARSER_OK
);
14134 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14136 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14138 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14140 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14142 salt_t
*salt
= hash_buf
->salt
;
14144 char *salt_buf
= input_buf
+ 6;
14146 char *digest_buf
= strchr (salt_buf
, '$');
14148 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14150 uint salt_len
= digest_buf
- salt_buf
;
14152 digest_buf
++; // skip the '$' symbol
14154 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14156 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14158 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14160 salt
->salt_len
= salt_len
;
14162 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14163 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14164 digest
[2] = hex_to_uint (&digest_buf
[16]);
14165 digest
[3] = hex_to_uint (&digest_buf
[24]);
14167 digest
[0] = byte_swap_32 (digest
[0]);
14168 digest
[1] = byte_swap_32 (digest
[1]);
14169 digest
[2] = byte_swap_32 (digest
[2]);
14170 digest
[3] = byte_swap_32 (digest
[3]);
14172 digest
[0] -= MD5M_A
;
14173 digest
[1] -= MD5M_B
;
14174 digest
[2] -= MD5M_C
;
14175 digest
[3] -= MD5M_D
;
14177 return (PARSER_OK
);
14180 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14182 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14184 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14186 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14188 salt_t
*salt
= hash_buf
->salt
;
14190 char *salt_buf
= input_buf
+ 3;
14192 char *digest_buf
= strchr (salt_buf
, '$');
14194 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14196 uint salt_len
= digest_buf
- salt_buf
;
14198 digest_buf
++; // skip the '$' symbol
14200 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14202 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14204 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14206 salt_buf_ptr
[salt_len
] = 0x2d;
14208 salt
->salt_len
= salt_len
+ 1;
14210 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14211 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14212 digest
[2] = hex_to_uint (&digest_buf
[16]);
14213 digest
[3] = hex_to_uint (&digest_buf
[24]);
14215 digest
[0] = byte_swap_32 (digest
[0]);
14216 digest
[1] = byte_swap_32 (digest
[1]);
14217 digest
[2] = byte_swap_32 (digest
[2]);
14218 digest
[3] = byte_swap_32 (digest
[3]);
14220 digest
[0] -= MD5M_A
;
14221 digest
[1] -= MD5M_B
;
14222 digest
[2] -= MD5M_C
;
14223 digest
[3] -= MD5M_D
;
14225 return (PARSER_OK
);
14228 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14230 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14232 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14236 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14238 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14240 memcpy (digest
, tmp_buf
, 20);
14242 digest
[0] = byte_swap_32 (digest
[0]);
14243 digest
[1] = byte_swap_32 (digest
[1]);
14244 digest
[2] = byte_swap_32 (digest
[2]);
14245 digest
[3] = byte_swap_32 (digest
[3]);
14246 digest
[4] = byte_swap_32 (digest
[4]);
14248 digest
[0] -= SHA1M_A
;
14249 digest
[1] -= SHA1M_B
;
14250 digest
[2] -= SHA1M_C
;
14251 digest
[3] -= SHA1M_D
;
14252 digest
[4] -= SHA1M_E
;
14254 return (PARSER_OK
);
14257 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14259 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14261 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14263 salt_t
*salt
= hash_buf
->salt
;
14265 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14266 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14267 digest
[2] = hex_to_uint (&input_buf
[16]);
14268 digest
[3] = hex_to_uint (&input_buf
[24]);
14270 digest
[0] = byte_swap_32 (digest
[0]);
14271 digest
[1] = byte_swap_32 (digest
[1]);
14272 digest
[2] = byte_swap_32 (digest
[2]);
14273 digest
[3] = byte_swap_32 (digest
[3]);
14275 digest
[0] -= MD5M_A
;
14276 digest
[1] -= MD5M_B
;
14277 digest
[2] -= MD5M_C
;
14278 digest
[3] -= MD5M_D
;
14280 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14282 uint salt_len
= input_len
- 32 - 1;
14284 char *salt_buf
= input_buf
+ 32 + 1;
14286 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14288 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14290 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14293 * add static "salt" part
14296 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14300 salt
->salt_len
= salt_len
;
14302 return (PARSER_OK
);
14305 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14307 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14309 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14311 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14313 salt_t
*salt
= hash_buf
->salt
;
14315 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14321 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14323 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14325 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14327 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14329 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14333 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14335 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14337 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14339 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14343 char *keybuf_pos
= strchr (keylen_pos
, '$');
14345 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14347 uint keylen_len
= keybuf_pos
- keylen_pos
;
14349 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14353 char *databuf_pos
= strchr (keybuf_pos
, '$');
14355 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14357 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14359 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14363 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14365 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14371 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14372 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14373 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14374 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14376 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14377 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14378 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14379 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14381 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14382 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14383 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14384 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14386 salt
->salt_len
= 16;
14387 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14389 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14391 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14394 return (PARSER_OK
);
14397 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14399 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14401 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14403 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14405 salt_t
*salt
= hash_buf
->salt
;
14411 // first is the N salt parameter
14413 char *N_pos
= input_buf
+ 6;
14415 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14419 salt
->scrypt_N
= atoi (N_pos
);
14423 char *r_pos
= strchr (N_pos
, ':');
14425 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14429 salt
->scrypt_r
= atoi (r_pos
);
14433 char *p_pos
= strchr (r_pos
, ':');
14435 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14439 salt
->scrypt_p
= atoi (p_pos
);
14443 char *saltbuf_pos
= strchr (p_pos
, ':');
14445 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14449 char *hash_pos
= strchr (saltbuf_pos
, ':');
14451 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14459 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14461 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14463 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14465 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14467 salt
->salt_len
= tmp_len
;
14468 salt
->salt_iter
= 1;
14470 // digest - base64 decode
14472 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14474 tmp_len
= input_len
- (hash_pos
- input_buf
);
14476 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14478 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14480 memcpy (digest
, tmp_buf
, 32);
14482 return (PARSER_OK
);
14485 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14487 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14489 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14491 salt_t
*salt
= hash_buf
->salt
;
14497 char decrypted
[76]; // iv + hash
14499 juniper_decrypt_hash (input_buf
, decrypted
);
14501 char *md5crypt_hash
= decrypted
+ 12;
14503 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14505 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14507 char *salt_pos
= md5crypt_hash
+ 3;
14509 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14511 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14513 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14517 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14519 return (PARSER_OK
);
14522 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14524 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14526 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14528 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14530 salt_t
*salt
= hash_buf
->salt
;
14532 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14538 // first is *raw* salt
14540 char *salt_pos
= input_buf
+ 3;
14542 char *hash_pos
= strchr (salt_pos
, '$');
14544 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14546 uint salt_len
= hash_pos
- salt_pos
;
14548 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14552 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14554 memcpy (salt_buf_ptr
, salt_pos
, 14);
14556 salt_buf_ptr
[17] = 0x01;
14557 salt_buf_ptr
[18] = 0x80;
14559 // add some stuff to normal salt to make sorted happy
14561 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14562 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14563 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14564 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14566 salt
->salt_len
= salt_len
;
14567 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14569 // base64 decode hash
14573 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14575 uint hash_len
= input_len
- 3 - salt_len
- 1;
14577 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14579 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14581 memcpy (digest
, tmp_buf
, 32);
14583 digest
[0] = byte_swap_32 (digest
[0]);
14584 digest
[1] = byte_swap_32 (digest
[1]);
14585 digest
[2] = byte_swap_32 (digest
[2]);
14586 digest
[3] = byte_swap_32 (digest
[3]);
14587 digest
[4] = byte_swap_32 (digest
[4]);
14588 digest
[5] = byte_swap_32 (digest
[5]);
14589 digest
[6] = byte_swap_32 (digest
[6]);
14590 digest
[7] = byte_swap_32 (digest
[7]);
14592 return (PARSER_OK
);
14595 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14597 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14599 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14601 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14603 salt_t
*salt
= hash_buf
->salt
;
14609 // first is *raw* salt
14611 char *salt_pos
= input_buf
+ 3;
14613 char *hash_pos
= strchr (salt_pos
, '$');
14615 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14617 uint salt_len
= hash_pos
- salt_pos
;
14619 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14621 salt
->salt_len
= salt_len
;
14624 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14626 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14627 salt_buf_ptr
[salt_len
] = 0;
14629 // base64 decode hash
14633 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14635 uint hash_len
= input_len
- 3 - salt_len
- 1;
14637 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14639 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14641 memcpy (digest
, tmp_buf
, 32);
14644 salt
->scrypt_N
= 16384;
14645 salt
->scrypt_r
= 1;
14646 salt
->scrypt_p
= 1;
14647 salt
->salt_iter
= 1;
14649 return (PARSER_OK
);
14652 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14654 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14656 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14658 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14660 salt_t
*salt
= hash_buf
->salt
;
14662 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14668 char *version_pos
= input_buf
+ 8 + 1;
14670 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14672 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14674 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14676 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14678 verifierHashSize_pos
++;
14680 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14682 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14684 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14686 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14690 char *saltSize_pos
= strchr (keySize_pos
, '*');
14692 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14694 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14696 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14700 char *osalt_pos
= strchr (saltSize_pos
, '*');
14702 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14704 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14706 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14710 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14712 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14714 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14716 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14718 encryptedVerifier_pos
++;
14720 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14722 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14724 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14726 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14728 encryptedVerifierHash_pos
++;
14730 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;
14732 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14734 const uint version
= atoi (version_pos
);
14736 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14738 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14740 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14742 const uint keySize
= atoi (keySize_pos
);
14744 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14746 office2007
->keySize
= keySize
;
14748 const uint saltSize
= atoi (saltSize_pos
);
14750 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14756 salt
->salt_len
= 16;
14757 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14759 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14760 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14761 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14762 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14768 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14769 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14770 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14771 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14773 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14774 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14775 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14776 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14777 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14783 digest
[0] = office2007
->encryptedVerifierHash
[0];
14784 digest
[1] = office2007
->encryptedVerifierHash
[1];
14785 digest
[2] = office2007
->encryptedVerifierHash
[2];
14786 digest
[3] = office2007
->encryptedVerifierHash
[3];
14788 return (PARSER_OK
);
14791 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14793 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14795 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14797 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14799 salt_t
*salt
= hash_buf
->salt
;
14801 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14807 char *version_pos
= input_buf
+ 8 + 1;
14809 char *spinCount_pos
= strchr (version_pos
, '*');
14811 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14813 uint32_t version_len
= spinCount_pos
- version_pos
;
14815 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14819 char *keySize_pos
= strchr (spinCount_pos
, '*');
14821 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14823 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14825 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14829 char *saltSize_pos
= strchr (keySize_pos
, '*');
14831 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14833 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14835 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14839 char *osalt_pos
= strchr (saltSize_pos
, '*');
14841 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14843 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14845 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14849 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14851 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14853 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14855 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14857 encryptedVerifier_pos
++;
14859 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14861 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14863 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14865 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14867 encryptedVerifierHash_pos
++;
14869 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;
14871 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14873 const uint version
= atoi (version_pos
);
14875 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14877 const uint spinCount
= atoi (spinCount_pos
);
14879 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14881 const uint keySize
= atoi (keySize_pos
);
14883 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14885 const uint saltSize
= atoi (saltSize_pos
);
14887 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14893 salt
->salt_len
= 16;
14894 salt
->salt_iter
= spinCount
;
14896 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14897 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14898 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14899 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14905 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14906 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14907 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14908 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14910 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14911 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14912 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14913 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14914 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14915 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14916 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14917 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14923 digest
[0] = office2010
->encryptedVerifierHash
[0];
14924 digest
[1] = office2010
->encryptedVerifierHash
[1];
14925 digest
[2] = office2010
->encryptedVerifierHash
[2];
14926 digest
[3] = office2010
->encryptedVerifierHash
[3];
14928 return (PARSER_OK
);
14931 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14933 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14935 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14937 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14939 salt_t
*salt
= hash_buf
->salt
;
14941 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14947 char *version_pos
= input_buf
+ 8 + 1;
14949 char *spinCount_pos
= strchr (version_pos
, '*');
14951 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14953 uint32_t version_len
= spinCount_pos
- version_pos
;
14955 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14959 char *keySize_pos
= strchr (spinCount_pos
, '*');
14961 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14963 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14965 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14969 char *saltSize_pos
= strchr (keySize_pos
, '*');
14971 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14973 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14975 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14979 char *osalt_pos
= strchr (saltSize_pos
, '*');
14981 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14983 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14985 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14989 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14991 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14993 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14995 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14997 encryptedVerifier_pos
++;
14999 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15001 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15003 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15005 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15007 encryptedVerifierHash_pos
++;
15009 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;
15011 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15013 const uint version
= atoi (version_pos
);
15015 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15017 const uint spinCount
= atoi (spinCount_pos
);
15019 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15021 const uint keySize
= atoi (keySize_pos
);
15023 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15025 const uint saltSize
= atoi (saltSize_pos
);
15027 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15033 salt
->salt_len
= 16;
15034 salt
->salt_iter
= spinCount
;
15036 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15037 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15038 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15039 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15045 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15046 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15047 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15048 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15050 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15051 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15052 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15053 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15054 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15055 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15056 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15057 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15063 digest
[0] = office2013
->encryptedVerifierHash
[0];
15064 digest
[1] = office2013
->encryptedVerifierHash
[1];
15065 digest
[2] = office2013
->encryptedVerifierHash
[2];
15066 digest
[3] = office2013
->encryptedVerifierHash
[3];
15068 return (PARSER_OK
);
15071 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15073 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15075 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15077 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15079 salt_t
*salt
= hash_buf
->salt
;
15081 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15087 char *version_pos
= input_buf
+ 11;
15089 char *osalt_pos
= strchr (version_pos
, '*');
15091 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15093 uint32_t version_len
= osalt_pos
- version_pos
;
15095 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15099 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15101 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15103 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15105 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15107 encryptedVerifier_pos
++;
15109 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15111 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15113 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15115 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15117 encryptedVerifierHash_pos
++;
15119 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15121 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15123 const uint version
= *version_pos
- 0x30;
15125 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15131 oldoffice01
->version
= version
;
15133 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15134 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15135 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15136 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15138 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15139 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15140 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15141 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15143 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15144 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15145 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15146 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15148 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15149 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15150 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15151 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15157 salt
->salt_len
= 16;
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]);
15164 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15165 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15166 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15167 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15169 // this is a workaround as office produces multiple documents with the same salt
15171 salt
->salt_len
+= 32;
15173 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15174 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15175 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15176 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15177 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15178 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15179 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15180 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15186 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15187 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15188 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15189 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15191 return (PARSER_OK
);
15194 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15196 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15199 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15201 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15203 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15205 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15207 salt_t
*salt
= hash_buf
->salt
;
15209 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15215 char *version_pos
= input_buf
+ 11;
15217 char *osalt_pos
= strchr (version_pos
, '*');
15219 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15221 uint32_t version_len
= osalt_pos
- version_pos
;
15223 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15227 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15229 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15231 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15233 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15235 encryptedVerifier_pos
++;
15237 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15239 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15241 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15243 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15245 encryptedVerifierHash_pos
++;
15247 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15249 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15251 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15253 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15257 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15259 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15261 const uint version
= *version_pos
- 0x30;
15263 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15269 oldoffice01
->version
= version
;
15271 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15272 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15273 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15274 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15276 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15277 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15278 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15279 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15281 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15282 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15283 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15284 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15286 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15287 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15288 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15289 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15291 oldoffice01
->rc4key
[1] = 0;
15292 oldoffice01
->rc4key
[0] = 0;
15294 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15295 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15296 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15297 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15298 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15299 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15300 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15301 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15302 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15303 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15305 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15306 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15312 salt
->salt_len
= 16;
15314 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15315 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15316 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15317 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15319 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15320 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15321 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15322 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15324 // this is a workaround as office produces multiple documents with the same salt
15326 salt
->salt_len
+= 32;
15328 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15329 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15330 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15331 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15332 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15333 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15334 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15335 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15341 digest
[0] = oldoffice01
->rc4key
[0];
15342 digest
[1] = oldoffice01
->rc4key
[1];
15346 return (PARSER_OK
);
15349 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15351 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15353 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15355 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15357 salt_t
*salt
= hash_buf
->salt
;
15359 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15365 char *version_pos
= input_buf
+ 11;
15367 char *osalt_pos
= strchr (version_pos
, '*');
15369 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15371 uint32_t version_len
= osalt_pos
- version_pos
;
15373 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15377 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15379 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15381 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15383 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15385 encryptedVerifier_pos
++;
15387 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15389 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15391 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15393 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15395 encryptedVerifierHash_pos
++;
15397 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15399 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15401 const uint version
= *version_pos
- 0x30;
15403 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15409 oldoffice34
->version
= version
;
15411 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15412 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15413 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15414 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15416 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15417 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15418 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15419 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15421 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15422 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15423 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15424 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15425 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15427 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15428 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15429 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15430 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15431 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15437 salt
->salt_len
= 16;
15439 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15440 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15441 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15442 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15444 // this is a workaround as office produces multiple documents with the same salt
15446 salt
->salt_len
+= 32;
15448 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15449 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15450 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15451 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15452 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15453 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15454 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15455 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15461 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15462 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15463 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15464 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15466 return (PARSER_OK
);
15469 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15471 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15473 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15476 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15478 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15480 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15482 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15484 salt_t
*salt
= hash_buf
->salt
;
15486 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15492 char *version_pos
= input_buf
+ 11;
15494 char *osalt_pos
= strchr (version_pos
, '*');
15496 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15498 uint32_t version_len
= osalt_pos
- version_pos
;
15500 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15504 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15506 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15508 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15510 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15512 encryptedVerifier_pos
++;
15514 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15516 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15518 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15520 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15522 encryptedVerifierHash_pos
++;
15524 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15526 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15528 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15530 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15534 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15536 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15538 const uint version
= *version_pos
- 0x30;
15540 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15546 oldoffice34
->version
= version
;
15548 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15549 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15550 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15551 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15553 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15554 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15555 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15556 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15558 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15559 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15560 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15561 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15562 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15564 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15565 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15566 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15567 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15568 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15570 oldoffice34
->rc4key
[1] = 0;
15571 oldoffice34
->rc4key
[0] = 0;
15573 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15574 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15575 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15576 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15577 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15578 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15579 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15580 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15581 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15582 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15584 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15585 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15591 salt
->salt_len
= 16;
15593 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15594 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15595 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15596 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15598 // this is a workaround as office produces multiple documents with the same salt
15600 salt
->salt_len
+= 32;
15602 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15603 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15604 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15605 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15606 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15607 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15608 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15609 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15615 digest
[0] = oldoffice34
->rc4key
[0];
15616 digest
[1] = oldoffice34
->rc4key
[1];
15620 return (PARSER_OK
);
15623 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15625 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15627 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15629 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15630 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15631 digest
[2] = hex_to_uint (&input_buf
[16]);
15632 digest
[3] = hex_to_uint (&input_buf
[24]);
15634 digest
[0] = byte_swap_32 (digest
[0]);
15635 digest
[1] = byte_swap_32 (digest
[1]);
15636 digest
[2] = byte_swap_32 (digest
[2]);
15637 digest
[3] = byte_swap_32 (digest
[3]);
15639 return (PARSER_OK
);
15642 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15644 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15646 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15648 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15650 salt_t
*salt
= hash_buf
->salt
;
15652 char *signature_pos
= input_buf
;
15654 char *salt_pos
= strchr (signature_pos
, '$');
15656 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15658 uint32_t signature_len
= salt_pos
- signature_pos
;
15660 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15664 char *hash_pos
= strchr (salt_pos
, '$');
15666 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15668 uint32_t salt_len
= hash_pos
- salt_pos
;
15670 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15674 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15676 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15678 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15679 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15680 digest
[2] = hex_to_uint (&hash_pos
[16]);
15681 digest
[3] = hex_to_uint (&hash_pos
[24]);
15682 digest
[4] = hex_to_uint (&hash_pos
[32]);
15684 digest
[0] -= SHA1M_A
;
15685 digest
[1] -= SHA1M_B
;
15686 digest
[2] -= SHA1M_C
;
15687 digest
[3] -= SHA1M_D
;
15688 digest
[4] -= SHA1M_E
;
15690 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15692 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15694 salt
->salt_len
= salt_len
;
15696 return (PARSER_OK
);
15699 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15701 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15703 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15705 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15707 salt_t
*salt
= hash_buf
->salt
;
15709 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15715 char *iter_pos
= input_buf
+ 14;
15717 const int iter
= atoi (iter_pos
);
15719 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15721 salt
->salt_iter
= iter
- 1;
15723 char *salt_pos
= strchr (iter_pos
, '$');
15725 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15729 char *hash_pos
= strchr (salt_pos
, '$');
15731 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15733 const uint salt_len
= hash_pos
- salt_pos
;
15737 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15739 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15741 salt
->salt_len
= salt_len
;
15743 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15744 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15746 // add some stuff to normal salt to make sorted happy
15748 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15749 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15750 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15751 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15752 salt
->salt_buf
[4] = salt
->salt_iter
;
15754 // base64 decode hash
15758 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15760 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15762 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15764 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15766 memcpy (digest
, tmp_buf
, 32);
15768 digest
[0] = byte_swap_32 (digest
[0]);
15769 digest
[1] = byte_swap_32 (digest
[1]);
15770 digest
[2] = byte_swap_32 (digest
[2]);
15771 digest
[3] = byte_swap_32 (digest
[3]);
15772 digest
[4] = byte_swap_32 (digest
[4]);
15773 digest
[5] = byte_swap_32 (digest
[5]);
15774 digest
[6] = byte_swap_32 (digest
[6]);
15775 digest
[7] = byte_swap_32 (digest
[7]);
15777 return (PARSER_OK
);
15780 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15782 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15784 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15786 salt_t
*salt
= hash_buf
->salt
;
15788 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15789 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15793 digest
[0] = byte_swap_32 (digest
[0]);
15794 digest
[1] = byte_swap_32 (digest
[1]);
15796 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15797 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15798 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15800 char iter_c
= input_buf
[17];
15801 char iter_d
= input_buf
[19];
15803 // atm only defaults, let's see if there's more request
15804 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15805 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15807 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15809 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15810 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15811 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15812 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15814 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15815 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15816 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15817 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15819 salt
->salt_len
= 16;
15821 return (PARSER_OK
);
15824 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15826 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15828 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15830 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15832 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15834 salt_t
*salt
= hash_buf
->salt
;
15836 char *salt_pos
= input_buf
+ 10;
15838 char *hash_pos
= strchr (salt_pos
, '$');
15840 uint salt_len
= hash_pos
- salt_pos
;
15842 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15846 uint hash_len
= input_len
- 10 - salt_len
- 1;
15848 // base64 decode salt
15852 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15854 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15856 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15858 tmp_buf
[salt_len
] = 0x80;
15860 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15862 salt
->salt_len
= salt_len
;
15864 // base64 decode salt
15866 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15868 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15870 uint user_len
= hash_len
- 32;
15872 char *tmp_hash
= tmp_buf
+ user_len
;
15874 user_len
--; // skip the trailing space
15876 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15877 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15878 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15879 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15881 digest
[0] = byte_swap_32 (digest
[0]);
15882 digest
[1] = byte_swap_32 (digest
[1]);
15883 digest
[2] = byte_swap_32 (digest
[2]);
15884 digest
[3] = byte_swap_32 (digest
[3]);
15886 // store username for host only (output hash if cracked)
15888 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15889 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15891 return (PARSER_OK
);
15894 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15896 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15898 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15900 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15902 salt_t
*salt
= hash_buf
->salt
;
15904 char *iter_pos
= input_buf
+ 10;
15906 uint32_t iter
= atoi (iter_pos
);
15910 return (PARSER_SALT_ITERATION
);
15913 iter
--; // first iteration is special
15915 salt
->salt_iter
= iter
;
15917 char *base64_pos
= strchr (iter_pos
, '}');
15919 if (base64_pos
== NULL
)
15921 return (PARSER_SIGNATURE_UNMATCHED
);
15926 // base64 decode salt
15928 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15932 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15934 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15936 if (decoded_len
< 24)
15938 return (PARSER_SALT_LENGTH
);
15943 uint salt_len
= decoded_len
- 20;
15945 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15946 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15948 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15950 salt
->salt_len
= salt_len
;
15954 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15956 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15957 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15958 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15959 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15960 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15962 return (PARSER_OK
);
15965 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15967 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15969 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15971 salt_t
*salt
= hash_buf
->salt
;
15973 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15974 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15975 digest
[2] = hex_to_uint (&input_buf
[16]);
15976 digest
[3] = hex_to_uint (&input_buf
[24]);
15977 digest
[4] = hex_to_uint (&input_buf
[32]);
15979 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15981 uint salt_len
= input_len
- 40 - 1;
15983 char *salt_buf
= input_buf
+ 40 + 1;
15985 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15987 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15989 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15991 salt
->salt_len
= salt_len
;
15993 return (PARSER_OK
);
15996 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15998 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16000 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16002 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16004 salt_t
*salt
= hash_buf
->salt
;
16006 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16012 char *V_pos
= input_buf
+ 5;
16014 char *R_pos
= strchr (V_pos
, '*');
16016 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16018 uint32_t V_len
= R_pos
- V_pos
;
16022 char *bits_pos
= strchr (R_pos
, '*');
16024 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16026 uint32_t R_len
= bits_pos
- R_pos
;
16030 char *P_pos
= strchr (bits_pos
, '*');
16032 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16034 uint32_t bits_len
= P_pos
- bits_pos
;
16038 char *enc_md_pos
= strchr (P_pos
, '*');
16040 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16042 uint32_t P_len
= enc_md_pos
- P_pos
;
16046 char *id_len_pos
= strchr (enc_md_pos
, '*');
16048 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16050 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16054 char *id_buf_pos
= strchr (id_len_pos
, '*');
16056 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16058 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16062 char *u_len_pos
= strchr (id_buf_pos
, '*');
16064 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16066 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16068 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16072 char *u_buf_pos
= strchr (u_len_pos
, '*');
16074 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16076 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16080 char *o_len_pos
= strchr (u_buf_pos
, '*');
16082 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16084 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16086 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16090 char *o_buf_pos
= strchr (o_len_pos
, '*');
16092 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16094 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16098 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;
16100 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16104 const int V
= atoi (V_pos
);
16105 const int R
= atoi (R_pos
);
16106 const int P
= atoi (P_pos
);
16108 if (V
!= 1) return (PARSER_SALT_VALUE
);
16109 if (R
!= 2) return (PARSER_SALT_VALUE
);
16111 const int enc_md
= atoi (enc_md_pos
);
16113 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16115 const int id_len
= atoi (id_len_pos
);
16116 const int u_len
= atoi (u_len_pos
);
16117 const int o_len
= atoi (o_len_pos
);
16119 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16120 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16121 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16123 const int bits
= atoi (bits_pos
);
16125 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16127 // copy data to esalt
16133 pdf
->enc_md
= enc_md
;
16135 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16136 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16137 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16138 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16139 pdf
->id_len
= id_len
;
16141 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16142 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16143 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16144 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16145 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16146 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16147 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16148 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16149 pdf
->u_len
= u_len
;
16151 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16152 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16153 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16154 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16155 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16156 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16157 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16158 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16159 pdf
->o_len
= o_len
;
16161 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16162 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16163 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16164 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16166 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16167 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16168 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16169 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16170 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16171 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16172 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16173 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16175 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16176 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16177 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16178 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16179 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16180 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16181 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16182 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16184 // we use ID for salt, maybe needs to change, we will see...
16186 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16187 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16188 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16189 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16190 salt
->salt_len
= pdf
->id_len
;
16192 digest
[0] = pdf
->u_buf
[0];
16193 digest
[1] = pdf
->u_buf
[1];
16194 digest
[2] = pdf
->u_buf
[2];
16195 digest
[3] = pdf
->u_buf
[3];
16197 return (PARSER_OK
);
16200 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16202 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16205 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16207 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16209 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16211 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16213 salt_t
*salt
= hash_buf
->salt
;
16215 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16221 char *V_pos
= input_buf
+ 5;
16223 char *R_pos
= strchr (V_pos
, '*');
16225 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16227 uint32_t V_len
= R_pos
- V_pos
;
16231 char *bits_pos
= strchr (R_pos
, '*');
16233 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16235 uint32_t R_len
= bits_pos
- R_pos
;
16239 char *P_pos
= strchr (bits_pos
, '*');
16241 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16243 uint32_t bits_len
= P_pos
- bits_pos
;
16247 char *enc_md_pos
= strchr (P_pos
, '*');
16249 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16251 uint32_t P_len
= enc_md_pos
- P_pos
;
16255 char *id_len_pos
= strchr (enc_md_pos
, '*');
16257 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16259 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16263 char *id_buf_pos
= strchr (id_len_pos
, '*');
16265 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16267 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16271 char *u_len_pos
= strchr (id_buf_pos
, '*');
16273 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16275 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16277 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16281 char *u_buf_pos
= strchr (u_len_pos
, '*');
16283 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16285 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16289 char *o_len_pos
= strchr (u_buf_pos
, '*');
16291 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16293 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16295 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16299 char *o_buf_pos
= strchr (o_len_pos
, '*');
16301 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16303 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16307 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16309 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16311 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16313 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16317 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;
16319 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16323 const int V
= atoi (V_pos
);
16324 const int R
= atoi (R_pos
);
16325 const int P
= atoi (P_pos
);
16327 if (V
!= 1) return (PARSER_SALT_VALUE
);
16328 if (R
!= 2) return (PARSER_SALT_VALUE
);
16330 const int enc_md
= atoi (enc_md_pos
);
16332 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16334 const int id_len
= atoi (id_len_pos
);
16335 const int u_len
= atoi (u_len_pos
);
16336 const int o_len
= atoi (o_len_pos
);
16338 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16339 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16340 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16342 const int bits
= atoi (bits_pos
);
16344 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16346 // copy data to esalt
16352 pdf
->enc_md
= enc_md
;
16354 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16355 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16356 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16357 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16358 pdf
->id_len
= id_len
;
16360 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16361 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16362 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16363 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16364 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16365 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16366 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16367 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16368 pdf
->u_len
= u_len
;
16370 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16371 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16372 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16373 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16374 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16375 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16376 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16377 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16378 pdf
->o_len
= o_len
;
16380 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16381 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16382 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16383 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16385 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16386 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16387 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16388 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16389 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16390 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16391 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16392 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16394 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16395 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16396 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16397 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16398 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16399 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16400 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16401 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16403 pdf
->rc4key
[1] = 0;
16404 pdf
->rc4key
[0] = 0;
16406 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16407 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16408 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16409 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16410 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16411 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16412 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16413 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16414 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16415 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16417 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16418 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16420 // we use ID for salt, maybe needs to change, we will see...
16422 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16423 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16424 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16425 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16426 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16427 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16428 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16429 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16430 salt
->salt_len
= pdf
->id_len
+ 16;
16432 digest
[0] = pdf
->rc4key
[0];
16433 digest
[1] = pdf
->rc4key
[1];
16437 return (PARSER_OK
);
16440 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16442 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16444 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16446 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16448 salt_t
*salt
= hash_buf
->salt
;
16450 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16456 char *V_pos
= input_buf
+ 5;
16458 char *R_pos
= strchr (V_pos
, '*');
16460 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16462 uint32_t V_len
= R_pos
- V_pos
;
16466 char *bits_pos
= strchr (R_pos
, '*');
16468 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16470 uint32_t R_len
= bits_pos
- R_pos
;
16474 char *P_pos
= strchr (bits_pos
, '*');
16476 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16478 uint32_t bits_len
= P_pos
- bits_pos
;
16482 char *enc_md_pos
= strchr (P_pos
, '*');
16484 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16486 uint32_t P_len
= enc_md_pos
- P_pos
;
16490 char *id_len_pos
= strchr (enc_md_pos
, '*');
16492 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16494 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16498 char *id_buf_pos
= strchr (id_len_pos
, '*');
16500 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16502 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16506 char *u_len_pos
= strchr (id_buf_pos
, '*');
16508 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16510 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16512 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16516 char *u_buf_pos
= strchr (u_len_pos
, '*');
16518 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16520 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16524 char *o_len_pos
= strchr (u_buf_pos
, '*');
16526 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16528 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16530 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16534 char *o_buf_pos
= strchr (o_len_pos
, '*');
16536 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16538 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16542 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;
16544 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16548 const int V
= atoi (V_pos
);
16549 const int R
= atoi (R_pos
);
16550 const int P
= atoi (P_pos
);
16554 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16555 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16557 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16559 const int id_len
= atoi (id_len_pos
);
16560 const int u_len
= atoi (u_len_pos
);
16561 const int o_len
= atoi (o_len_pos
);
16563 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16565 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16566 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16568 const int bits
= atoi (bits_pos
);
16570 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16576 enc_md
= atoi (enc_md_pos
);
16579 // copy data to esalt
16585 pdf
->enc_md
= enc_md
;
16587 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16588 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16589 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16590 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16594 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16595 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16596 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16597 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16600 pdf
->id_len
= id_len
;
16602 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16603 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16604 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16605 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16606 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16607 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16608 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16609 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16610 pdf
->u_len
= u_len
;
16612 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16613 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16614 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16615 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16616 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16617 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16618 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16619 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16620 pdf
->o_len
= o_len
;
16622 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16623 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16624 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16625 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16629 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16630 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16631 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16632 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16635 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16636 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16637 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16638 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16639 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16640 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16641 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16642 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16644 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16645 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16646 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16647 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16648 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16649 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16650 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16651 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16653 // precompute rc4 data for later use
16669 uint salt_pc_block
[32];
16671 char *salt_pc_ptr
= (char *) salt_pc_block
;
16673 memcpy (salt_pc_ptr
, padding
, 32);
16674 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16676 uint salt_pc_digest
[4];
16678 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16680 pdf
->rc4data
[0] = salt_pc_digest
[0];
16681 pdf
->rc4data
[1] = salt_pc_digest
[1];
16683 // we use ID for salt, maybe needs to change, we will see...
16685 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16686 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16687 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16688 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16689 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16690 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16691 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16692 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16693 salt
->salt_len
= pdf
->id_len
+ 16;
16695 salt
->salt_iter
= ROUNDS_PDF14
;
16697 digest
[0] = pdf
->u_buf
[0];
16698 digest
[1] = pdf
->u_buf
[1];
16702 return (PARSER_OK
);
16705 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16707 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16709 if (ret
!= PARSER_OK
)
16714 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16716 salt_t
*salt
= hash_buf
->salt
;
16718 digest
[0] -= SHA256M_A
;
16719 digest
[1] -= SHA256M_B
;
16720 digest
[2] -= SHA256M_C
;
16721 digest
[3] -= SHA256M_D
;
16722 digest
[4] -= SHA256M_E
;
16723 digest
[5] -= SHA256M_F
;
16724 digest
[6] -= SHA256M_G
;
16725 digest
[7] -= SHA256M_H
;
16727 salt
->salt_buf
[2] = 0x80;
16729 return (PARSER_OK
);
16732 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16734 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16736 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16738 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16740 salt_t
*salt
= hash_buf
->salt
;
16742 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16748 char *V_pos
= input_buf
+ 5;
16750 char *R_pos
= strchr (V_pos
, '*');
16752 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16754 uint32_t V_len
= R_pos
- V_pos
;
16758 char *bits_pos
= strchr (R_pos
, '*');
16760 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16762 uint32_t R_len
= bits_pos
- R_pos
;
16766 char *P_pos
= strchr (bits_pos
, '*');
16768 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16770 uint32_t bits_len
= P_pos
- bits_pos
;
16774 char *enc_md_pos
= strchr (P_pos
, '*');
16776 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16778 uint32_t P_len
= enc_md_pos
- P_pos
;
16782 char *id_len_pos
= strchr (enc_md_pos
, '*');
16784 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16786 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16790 char *id_buf_pos
= strchr (id_len_pos
, '*');
16792 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16794 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16798 char *u_len_pos
= strchr (id_buf_pos
, '*');
16800 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16802 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16806 char *u_buf_pos
= strchr (u_len_pos
, '*');
16808 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16810 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16814 char *o_len_pos
= strchr (u_buf_pos
, '*');
16816 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16818 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16822 char *o_buf_pos
= strchr (o_len_pos
, '*');
16824 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16826 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16830 char *last
= strchr (o_buf_pos
, '*');
16832 if (last
== NULL
) last
= input_buf
+ input_len
;
16834 uint32_t o_buf_len
= last
- o_buf_pos
;
16838 const int V
= atoi (V_pos
);
16839 const int R
= atoi (R_pos
);
16843 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16844 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16846 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16848 const int bits
= atoi (bits_pos
);
16850 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16852 int enc_md
= atoi (enc_md_pos
);
16854 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16856 const uint id_len
= atoi (id_len_pos
);
16857 const uint u_len
= atoi (u_len_pos
);
16858 const uint o_len
= atoi (o_len_pos
);
16860 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16861 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16862 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16863 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16864 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16865 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16866 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16867 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16869 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16870 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16871 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16873 // copy data to esalt
16875 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16877 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16879 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16882 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16883 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16885 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16886 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16888 salt
->salt_len
= 8;
16889 salt
->salt_iter
= ROUNDS_PDF17L8
;
16891 digest
[0] = pdf
->u_buf
[0];
16892 digest
[1] = pdf
->u_buf
[1];
16893 digest
[2] = pdf
->u_buf
[2];
16894 digest
[3] = pdf
->u_buf
[3];
16895 digest
[4] = pdf
->u_buf
[4];
16896 digest
[5] = pdf
->u_buf
[5];
16897 digest
[6] = pdf
->u_buf
[6];
16898 digest
[7] = pdf
->u_buf
[7];
16900 return (PARSER_OK
);
16903 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16905 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16907 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16909 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16911 salt_t
*salt
= hash_buf
->salt
;
16913 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16921 char *iter_pos
= input_buf
+ 7;
16923 uint32_t iter
= atoi (iter_pos
);
16925 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16926 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16928 // first is *raw* salt
16930 char *salt_pos
= strchr (iter_pos
, ':');
16932 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16936 char *hash_pos
= strchr (salt_pos
, ':');
16938 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16940 uint32_t salt_len
= hash_pos
- salt_pos
;
16942 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16946 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16948 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16952 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16954 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16956 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16958 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16959 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16961 salt
->salt_len
= salt_len
;
16962 salt
->salt_iter
= iter
- 1;
16968 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16970 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16972 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16974 memcpy (digest
, tmp_buf
, 16);
16976 digest
[0] = byte_swap_32 (digest
[0]);
16977 digest
[1] = byte_swap_32 (digest
[1]);
16978 digest
[2] = byte_swap_32 (digest
[2]);
16979 digest
[3] = byte_swap_32 (digest
[3]);
16981 // add some stuff to normal salt to make sorted happy
16983 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16984 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16985 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16986 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16987 salt
->salt_buf
[4] = salt
->salt_iter
;
16989 return (PARSER_OK
);
16992 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16994 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16996 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16998 salt_t
*salt
= hash_buf
->salt
;
17000 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17001 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17002 digest
[2] = hex_to_uint (&input_buf
[16]);
17003 digest
[3] = hex_to_uint (&input_buf
[24]);
17005 digest
[0] = byte_swap_32 (digest
[0]);
17006 digest
[1] = byte_swap_32 (digest
[1]);
17007 digest
[2] = byte_swap_32 (digest
[2]);
17008 digest
[3] = byte_swap_32 (digest
[3]);
17010 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17012 uint salt_len
= input_len
- 32 - 1;
17014 char *salt_buf
= input_buf
+ 32 + 1;
17016 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17018 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17020 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17022 salt
->salt_len
= salt_len
;
17024 return (PARSER_OK
);
17027 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17029 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17031 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17033 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17035 salt_t
*salt
= hash_buf
->salt
;
17037 char *user_pos
= input_buf
+ 10;
17039 char *salt_pos
= strchr (user_pos
, '*');
17041 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17045 char *hash_pos
= strchr (salt_pos
, '*');
17049 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17051 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17053 uint user_len
= salt_pos
- user_pos
- 1;
17055 uint salt_len
= hash_pos
- salt_pos
- 1;
17057 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17063 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17064 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17065 digest
[2] = hex_to_uint (&hash_pos
[16]);
17066 digest
[3] = hex_to_uint (&hash_pos
[24]);
17068 digest
[0] = byte_swap_32 (digest
[0]);
17069 digest
[1] = byte_swap_32 (digest
[1]);
17070 digest
[2] = byte_swap_32 (digest
[2]);
17071 digest
[3] = byte_swap_32 (digest
[3]);
17073 digest
[0] -= MD5M_A
;
17074 digest
[1] -= MD5M_B
;
17075 digest
[2] -= MD5M_C
;
17076 digest
[3] -= MD5M_D
;
17082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17084 // first 4 bytes are the "challenge"
17086 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17087 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17088 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17089 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17091 // append the user name
17093 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17095 salt
->salt_len
= 4 + user_len
;
17097 return (PARSER_OK
);
17100 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17102 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17104 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17106 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17108 salt_t
*salt
= hash_buf
->salt
;
17110 char *salt_pos
= input_buf
+ 9;
17112 char *hash_pos
= strchr (salt_pos
, '*');
17114 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17118 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17120 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17122 uint salt_len
= hash_pos
- salt_pos
- 1;
17124 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17130 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17131 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17132 digest
[2] = hex_to_uint (&hash_pos
[16]);
17133 digest
[3] = hex_to_uint (&hash_pos
[24]);
17134 digest
[4] = hex_to_uint (&hash_pos
[32]);
17140 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17142 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17144 salt
->salt_len
= salt_len
;
17146 return (PARSER_OK
);
17149 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17151 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17153 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17155 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17157 salt_t
*salt
= hash_buf
->salt
;
17159 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17165 char *cry_master_len_pos
= input_buf
+ 9;
17167 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17169 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17171 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17173 cry_master_buf_pos
++;
17175 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17177 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17179 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17181 cry_salt_len_pos
++;
17183 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17185 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17187 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17189 cry_salt_buf_pos
++;
17191 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17193 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17195 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17199 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17201 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17203 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17207 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17209 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17211 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17215 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17217 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17219 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17221 public_key_len_pos
++;
17223 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17225 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17227 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17229 public_key_buf_pos
++;
17231 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;
17233 const uint cry_master_len
= atoi (cry_master_len_pos
);
17234 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17235 const uint ckey_len
= atoi (ckey_len_pos
);
17236 const uint public_key_len
= atoi (public_key_len_pos
);
17238 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17239 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17240 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17241 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17243 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17245 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17247 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17250 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17252 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17254 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17257 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17259 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17261 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17264 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17265 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17266 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17269 * store digest (should be unique enought, hopefully)
17272 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17273 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17274 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17275 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17281 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17283 const uint cry_rounds
= atoi (cry_rounds_pos
);
17285 salt
->salt_iter
= cry_rounds
- 1;
17287 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17289 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17291 salt
->salt_len
= salt_len
;
17293 return (PARSER_OK
);
17296 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17298 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17300 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17302 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17304 salt_t
*salt
= hash_buf
->salt
;
17306 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17308 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17310 char temp_input_buf
[input_len
+ 1];
17312 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17313 memcpy (temp_input_buf
, input_buf
, input_len
);
17317 char *URI_server_pos
= temp_input_buf
+ 6;
17319 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17321 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17323 URI_client_pos
[0] = 0;
17326 uint URI_server_len
= strlen (URI_server_pos
);
17328 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17332 char *user_pos
= strchr (URI_client_pos
, '*');
17334 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17339 uint URI_client_len
= strlen (URI_client_pos
);
17341 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17345 char *realm_pos
= strchr (user_pos
, '*');
17347 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17352 uint user_len
= strlen (user_pos
);
17354 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17358 char *method_pos
= strchr (realm_pos
, '*');
17360 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17365 uint realm_len
= strlen (realm_pos
);
17367 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17371 char *URI_prefix_pos
= strchr (method_pos
, '*');
17373 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17375 URI_prefix_pos
[0] = 0;
17378 uint method_len
= strlen (method_pos
);
17380 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17384 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17386 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17388 URI_resource_pos
[0] = 0;
17389 URI_resource_pos
++;
17391 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17393 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17397 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17399 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17401 URI_suffix_pos
[0] = 0;
17404 uint URI_resource_len
= strlen (URI_resource_pos
);
17406 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17407 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17411 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17413 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17418 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17420 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17424 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17426 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17428 nonce_client_pos
[0] = 0;
17429 nonce_client_pos
++;
17431 uint nonce_len
= strlen (nonce_pos
);
17433 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17434 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17438 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17440 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17442 nonce_count_pos
[0] = 0;
17445 uint nonce_client_len
= strlen (nonce_client_pos
);
17447 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17451 char *qop_pos
= strchr (nonce_count_pos
, '*');
17453 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17458 uint nonce_count_len
= strlen (nonce_count_pos
);
17460 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17464 char *directive_pos
= strchr (qop_pos
, '*');
17466 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17468 directive_pos
[0] = 0;
17471 uint qop_len
= strlen (qop_pos
);
17473 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17477 char *digest_pos
= strchr (directive_pos
, '*');
17479 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17484 uint directive_len
= strlen (directive_pos
);
17486 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17488 if (memcmp (directive_pos
, "MD5", 3))
17490 log_info ("ERROR: only the MD5 directive is currently supported\n");
17492 return (PARSER_SIP_AUTH_DIRECTIVE
);
17496 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17501 uint md5_max_len
= 4 * 64;
17503 uint md5_remaining_len
= md5_max_len
;
17505 uint tmp_md5_buf
[md5_max_len
/ 4];
17507 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17509 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17511 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17513 md5_len
+= method_len
+ 1;
17514 tmp_md5_ptr
+= method_len
+ 1;
17516 if (URI_prefix_len
> 0)
17518 md5_remaining_len
= md5_max_len
- md5_len
;
17520 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17522 md5_len
+= URI_prefix_len
+ 1;
17523 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17526 md5_remaining_len
= md5_max_len
- md5_len
;
17528 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17530 md5_len
+= URI_resource_len
;
17531 tmp_md5_ptr
+= URI_resource_len
;
17533 if (URI_suffix_len
> 0)
17535 md5_remaining_len
= md5_max_len
- md5_len
;
17537 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17539 md5_len
+= 1 + URI_suffix_len
;
17542 uint tmp_digest
[4];
17544 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17546 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17547 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17548 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17549 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17555 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17557 uint esalt_len
= 0;
17559 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17561 // there are 2 possibilities for the esalt:
17563 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17565 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17567 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17569 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17581 esalt_len
= 1 + nonce_len
+ 1 + 32;
17583 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17585 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17593 // add 0x80 to esalt
17595 esalt_buf_ptr
[esalt_len
] = 0x80;
17597 sip
->esalt_len
= esalt_len
;
17603 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17605 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17607 uint max_salt_len
= 119;
17609 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17611 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17613 sip
->salt_len
= salt_len
;
17616 * fake salt (for sorting)
17619 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17623 uint fake_salt_len
= salt_len
;
17625 if (fake_salt_len
> max_salt_len
)
17627 fake_salt_len
= max_salt_len
;
17630 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17632 salt
->salt_len
= fake_salt_len
;
17638 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17639 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17640 digest
[2] = hex_to_uint (&digest_pos
[16]);
17641 digest
[3] = hex_to_uint (&digest_pos
[24]);
17643 digest
[0] = byte_swap_32 (digest
[0]);
17644 digest
[1] = byte_swap_32 (digest
[1]);
17645 digest
[2] = byte_swap_32 (digest
[2]);
17646 digest
[3] = byte_swap_32 (digest
[3]);
17648 return (PARSER_OK
);
17651 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17653 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17655 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17657 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17659 salt_t
*salt
= hash_buf
->salt
;
17663 char *digest_pos
= input_buf
;
17665 digest
[0] = hex_to_uint (&digest_pos
[0]);
17672 char *salt_buf
= input_buf
+ 8 + 1;
17676 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17678 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17680 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17682 salt
->salt_len
= salt_len
;
17684 return (PARSER_OK
);
17687 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17689 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17691 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17693 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17695 salt_t
*salt
= hash_buf
->salt
;
17697 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17703 char *p_buf_pos
= input_buf
+ 4;
17705 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17707 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17709 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17711 NumCyclesPower_pos
++;
17713 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17715 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17717 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17721 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17723 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17725 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17729 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17731 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17733 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17737 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17739 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17741 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17745 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17747 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17749 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17753 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17755 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17757 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17761 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17763 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17765 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17769 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17771 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17773 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17777 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;
17779 const uint iter
= atoi (NumCyclesPower_pos
);
17780 const uint crc
= atoi (crc_buf_pos
);
17781 const uint p_buf
= atoi (p_buf_pos
);
17782 const uint salt_len
= atoi (salt_len_pos
);
17783 const uint iv_len
= atoi (iv_len_pos
);
17784 const uint unpack_size
= atoi (unpack_size_pos
);
17785 const uint data_len
= atoi (data_len_pos
);
17791 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17792 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17794 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17796 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17798 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17804 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17805 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17806 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17807 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17809 seven_zip
->iv_len
= iv_len
;
17811 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17813 seven_zip
->salt_len
= 0;
17815 seven_zip
->crc
= crc
;
17817 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17819 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17821 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17824 seven_zip
->data_len
= data_len
;
17826 seven_zip
->unpack_size
= unpack_size
;
17830 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17831 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17832 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17833 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17835 salt
->salt_len
= 16;
17837 salt
->salt_sign
[0] = iter
;
17839 salt
->salt_iter
= 1 << iter
;
17850 return (PARSER_OK
);
17853 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17855 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17857 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17859 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17860 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17861 digest
[2] = hex_to_uint (&input_buf
[16]);
17862 digest
[3] = hex_to_uint (&input_buf
[24]);
17863 digest
[4] = hex_to_uint (&input_buf
[32]);
17864 digest
[5] = hex_to_uint (&input_buf
[40]);
17865 digest
[6] = hex_to_uint (&input_buf
[48]);
17866 digest
[7] = hex_to_uint (&input_buf
[56]);
17868 digest
[0] = byte_swap_32 (digest
[0]);
17869 digest
[1] = byte_swap_32 (digest
[1]);
17870 digest
[2] = byte_swap_32 (digest
[2]);
17871 digest
[3] = byte_swap_32 (digest
[3]);
17872 digest
[4] = byte_swap_32 (digest
[4]);
17873 digest
[5] = byte_swap_32 (digest
[5]);
17874 digest
[6] = byte_swap_32 (digest
[6]);
17875 digest
[7] = byte_swap_32 (digest
[7]);
17877 return (PARSER_OK
);
17880 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17882 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17884 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17886 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17887 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17888 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17889 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17890 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17891 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17892 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17893 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17894 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17895 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17896 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17897 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17898 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17899 digest
[13] = hex_to_uint (&input_buf
[104]);
17900 digest
[14] = hex_to_uint (&input_buf
[112]);
17901 digest
[15] = hex_to_uint (&input_buf
[120]);
17903 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17904 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17905 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17906 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17907 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17908 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17909 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17910 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17911 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17912 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17913 digest
[10] = byte_swap_32 (digest
[10]);
17914 digest
[11] = byte_swap_32 (digest
[11]);
17915 digest
[12] = byte_swap_32 (digest
[12]);
17916 digest
[13] = byte_swap_32 (digest
[13]);
17917 digest
[14] = byte_swap_32 (digest
[14]);
17918 digest
[15] = byte_swap_32 (digest
[15]);
17920 return (PARSER_OK
);
17923 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17925 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17927 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17929 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17931 salt_t
*salt
= hash_buf
->salt
;
17933 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17941 char *iter_pos
= input_buf
+ 4;
17943 uint32_t iter
= atoi (iter_pos
);
17945 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17946 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17948 // first is *raw* salt
17950 char *salt_pos
= strchr (iter_pos
, ':');
17952 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17956 char *hash_pos
= strchr (salt_pos
, ':');
17958 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17960 uint32_t salt_len
= hash_pos
- salt_pos
;
17962 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17966 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17968 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17972 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17974 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17976 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17978 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17979 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17981 salt
->salt_len
= salt_len
;
17982 salt
->salt_iter
= iter
- 1;
17988 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17990 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17992 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17994 memcpy (digest
, tmp_buf
, 16);
17996 // add some stuff to normal salt to make sorted happy
17998 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17999 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18000 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18001 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18002 salt
->salt_buf
[4] = salt
->salt_iter
;
18004 return (PARSER_OK
);
18007 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18009 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18011 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18013 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18015 salt_t
*salt
= hash_buf
->salt
;
18017 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18025 char *iter_pos
= input_buf
+ 5;
18027 uint32_t iter
= atoi (iter_pos
);
18029 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18030 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18032 // first is *raw* salt
18034 char *salt_pos
= strchr (iter_pos
, ':');
18036 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18040 char *hash_pos
= strchr (salt_pos
, ':');
18042 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18044 uint32_t salt_len
= hash_pos
- salt_pos
;
18046 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18050 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18052 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18056 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18058 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18060 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18062 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18063 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18065 salt
->salt_len
= salt_len
;
18066 salt
->salt_iter
= iter
- 1;
18072 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18074 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18076 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18078 memcpy (digest
, tmp_buf
, 16);
18080 digest
[0] = byte_swap_32 (digest
[0]);
18081 digest
[1] = byte_swap_32 (digest
[1]);
18082 digest
[2] = byte_swap_32 (digest
[2]);
18083 digest
[3] = byte_swap_32 (digest
[3]);
18085 // add some stuff to normal salt to make sorted happy
18087 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18088 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18089 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18090 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18091 salt
->salt_buf
[4] = salt
->salt_iter
;
18093 return (PARSER_OK
);
18096 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18098 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18100 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18102 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18104 salt_t
*salt
= hash_buf
->salt
;
18106 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18114 char *iter_pos
= input_buf
+ 7;
18116 uint32_t iter
= atoi (iter_pos
);
18118 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18119 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18121 // first is *raw* salt
18123 char *salt_pos
= strchr (iter_pos
, ':');
18125 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18129 char *hash_pos
= strchr (salt_pos
, ':');
18131 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18133 uint32_t salt_len
= hash_pos
- salt_pos
;
18135 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18139 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18141 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18145 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18151 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18152 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18154 salt
->salt_len
= salt_len
;
18155 salt
->salt_iter
= iter
- 1;
18161 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18163 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18165 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18167 memcpy (digest
, tmp_buf
, 64);
18169 digest
[0] = byte_swap_64 (digest
[0]);
18170 digest
[1] = byte_swap_64 (digest
[1]);
18171 digest
[2] = byte_swap_64 (digest
[2]);
18172 digest
[3] = byte_swap_64 (digest
[3]);
18173 digest
[4] = byte_swap_64 (digest
[4]);
18174 digest
[5] = byte_swap_64 (digest
[5]);
18175 digest
[6] = byte_swap_64 (digest
[6]);
18176 digest
[7] = byte_swap_64 (digest
[7]);
18178 // add some stuff to normal salt to make sorted happy
18180 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18181 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18182 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18183 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18184 salt
->salt_buf
[4] = salt
->salt_iter
;
18186 return (PARSER_OK
);
18189 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18191 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18193 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18195 uint
*digest
= (uint
*) hash_buf
->digest
;
18197 salt_t
*salt
= hash_buf
->salt
;
18203 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18205 char *hash_pos
= strchr (salt_pos
, '$');
18207 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18209 uint32_t salt_len
= hash_pos
- salt_pos
;
18211 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18215 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18217 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18221 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18222 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18240 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18241 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18243 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18244 salt
->salt_len
= 8;
18246 return (PARSER_OK
);
18249 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18251 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18253 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18255 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18257 if (c19
& 3) return (PARSER_HASH_VALUE
);
18259 salt_t
*salt
= hash_buf
->salt
;
18261 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18265 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18266 | itoa64_to_int (input_buf
[2]) << 6
18267 | itoa64_to_int (input_buf
[3]) << 12
18268 | itoa64_to_int (input_buf
[4]) << 18;
18272 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18273 | itoa64_to_int (input_buf
[6]) << 6
18274 | itoa64_to_int (input_buf
[7]) << 12
18275 | itoa64_to_int (input_buf
[8]) << 18;
18277 salt
->salt_len
= 4;
18281 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18283 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18285 memcpy (digest
, tmp_buf
, 8);
18289 IP (digest
[0], digest
[1], tt
);
18291 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18292 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18296 return (PARSER_OK
);
18299 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18301 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18303 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18305 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18307 salt_t
*salt
= hash_buf
->salt
;
18313 char *type_pos
= input_buf
+ 6 + 1;
18315 char *salt_pos
= strchr (type_pos
, '*');
18317 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18319 uint32_t type_len
= salt_pos
- type_pos
;
18321 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18325 char *crypted_pos
= strchr (salt_pos
, '*');
18327 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18329 uint32_t salt_len
= crypted_pos
- salt_pos
;
18331 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18335 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18337 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18343 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18344 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18346 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18347 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18349 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18350 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18351 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18352 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18354 salt
->salt_len
= 24;
18355 salt
->salt_iter
= ROUNDS_RAR3
;
18357 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18358 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18360 digest
[0] = 0xc43d7b00;
18361 digest
[1] = 0x40070000;
18365 return (PARSER_OK
);
18368 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18370 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18372 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18374 salt_t
*salt
= hash_buf
->salt
;
18376 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18377 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18378 digest
[2] = hex_to_uint (&input_buf
[16]);
18379 digest
[3] = hex_to_uint (&input_buf
[24]);
18380 digest
[4] = hex_to_uint (&input_buf
[32]);
18381 digest
[5] = hex_to_uint (&input_buf
[40]);
18382 digest
[6] = hex_to_uint (&input_buf
[48]);
18383 digest
[7] = hex_to_uint (&input_buf
[56]);
18385 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18387 uint salt_len
= input_len
- 64 - 1;
18389 char *salt_buf
= input_buf
+ 64 + 1;
18391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18393 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18395 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18397 salt
->salt_len
= salt_len
;
18400 * we can precompute the first sha256 transform
18405 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18406 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18407 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18408 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18409 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18410 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18411 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18412 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18413 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18414 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18415 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18416 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18417 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18418 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18419 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18420 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18424 pc256
[0] = SHA256M_A
;
18425 pc256
[1] = SHA256M_B
;
18426 pc256
[2] = SHA256M_C
;
18427 pc256
[3] = SHA256M_D
;
18428 pc256
[4] = SHA256M_E
;
18429 pc256
[5] = SHA256M_F
;
18430 pc256
[6] = SHA256M_G
;
18431 pc256
[7] = SHA256M_H
;
18433 sha256_64 (w
, pc256
);
18435 salt
->salt_buf_pc
[0] = pc256
[0];
18436 salt
->salt_buf_pc
[1] = pc256
[1];
18437 salt
->salt_buf_pc
[2] = pc256
[2];
18438 salt
->salt_buf_pc
[3] = pc256
[3];
18439 salt
->salt_buf_pc
[4] = pc256
[4];
18440 salt
->salt_buf_pc
[5] = pc256
[5];
18441 salt
->salt_buf_pc
[6] = pc256
[6];
18442 salt
->salt_buf_pc
[7] = pc256
[7];
18444 digest
[0] -= pc256
[0];
18445 digest
[1] -= pc256
[1];
18446 digest
[2] -= pc256
[2];
18447 digest
[3] -= pc256
[3];
18448 digest
[4] -= pc256
[4];
18449 digest
[5] -= pc256
[5];
18450 digest
[6] -= pc256
[6];
18451 digest
[7] -= pc256
[7];
18453 return (PARSER_OK
);
18456 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18458 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18460 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18462 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18464 salt_t
*salt
= hash_buf
->salt
;
18470 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18472 char *data_buf_pos
= strchr (data_len_pos
, '$');
18474 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18476 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18478 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18479 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18483 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18485 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18487 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18489 uint32_t data_len
= atoi (data_len_pos
);
18491 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18497 char *salt_pos
= data_buf_pos
;
18499 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18500 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18501 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18502 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18504 // this is actually the CT, which is also the hash later (if matched)
18506 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18507 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18508 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18509 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18511 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18513 salt
->salt_iter
= 10 - 1;
18519 digest
[0] = salt
->salt_buf
[4];
18520 digest
[1] = salt
->salt_buf
[5];
18521 digest
[2] = salt
->salt_buf
[6];
18522 digest
[3] = salt
->salt_buf
[7];
18524 return (PARSER_OK
);
18527 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18529 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18531 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18533 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18535 salt_t
*salt
= hash_buf
->salt
;
18541 char *salt_pos
= input_buf
+ 11 + 1;
18543 char *iter_pos
= strchr (salt_pos
, ',');
18545 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18547 uint32_t salt_len
= iter_pos
- salt_pos
;
18549 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18553 char *hash_pos
= strchr (iter_pos
, ',');
18555 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18557 uint32_t iter_len
= hash_pos
- iter_pos
;
18559 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18563 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18565 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18571 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18572 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18573 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18574 salt
->salt_buf
[3] = 0x00018000;
18576 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18577 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18578 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18579 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18581 salt
->salt_len
= salt_len
/ 2;
18583 salt
->salt_iter
= atoi (iter_pos
) - 1;
18589 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18590 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18591 digest
[2] = hex_to_uint (&hash_pos
[16]);
18592 digest
[3] = hex_to_uint (&hash_pos
[24]);
18593 digest
[4] = hex_to_uint (&hash_pos
[32]);
18594 digest
[5] = hex_to_uint (&hash_pos
[40]);
18595 digest
[6] = hex_to_uint (&hash_pos
[48]);
18596 digest
[7] = hex_to_uint (&hash_pos
[56]);
18598 return (PARSER_OK
);
18601 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18603 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
18605 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18607 salt_t
*salt
= hash_buf
->salt
;
18613 char *hash_pos
= input_buf
+ 64;
18614 char *salt1_pos
= input_buf
+ 128;
18615 char *salt2_pos
= input_buf
;
18621 salt
->salt_buf
[ 0] = hex_to_uint (&salt1_pos
[ 0]);
18622 salt
->salt_buf
[ 1] = hex_to_uint (&salt1_pos
[ 8]);
18623 salt
->salt_buf
[ 2] = hex_to_uint (&salt1_pos
[16]);
18624 salt
->salt_buf
[ 3] = hex_to_uint (&salt1_pos
[24]);
18626 salt
->salt_buf
[ 4] = hex_to_uint (&salt2_pos
[ 0]);
18627 salt
->salt_buf
[ 5] = hex_to_uint (&salt2_pos
[ 8]);
18628 salt
->salt_buf
[ 6] = hex_to_uint (&salt2_pos
[16]);
18629 salt
->salt_buf
[ 7] = hex_to_uint (&salt2_pos
[24]);
18631 salt
->salt_buf
[ 8] = hex_to_uint (&salt2_pos
[32]);
18632 salt
->salt_buf
[ 9] = hex_to_uint (&salt2_pos
[40]);
18633 salt
->salt_buf
[10] = hex_to_uint (&salt2_pos
[48]);
18634 salt
->salt_buf
[11] = hex_to_uint (&salt2_pos
[56]);
18636 salt
->salt_len
= 48;
18638 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
18644 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18645 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18646 digest
[2] = hex_to_uint (&hash_pos
[16]);
18647 digest
[3] = hex_to_uint (&hash_pos
[24]);
18648 digest
[4] = hex_to_uint (&hash_pos
[32]);
18649 digest
[5] = hex_to_uint (&hash_pos
[40]);
18650 digest
[6] = hex_to_uint (&hash_pos
[48]);
18651 digest
[7] = hex_to_uint (&hash_pos
[56]);
18653 return (PARSER_OK
);
18657 * parallel running threads
18662 BOOL WINAPI
sigHandler_default (DWORD sig
)
18666 case CTRL_CLOSE_EVENT
:
18669 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18670 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18671 * function otherwise it is to late (e.g. after returning from this function)
18676 SetConsoleCtrlHandler (NULL
, TRUE
);
18683 case CTRL_LOGOFF_EVENT
:
18684 case CTRL_SHUTDOWN_EVENT
:
18688 SetConsoleCtrlHandler (NULL
, TRUE
);
18696 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18700 case CTRL_CLOSE_EVENT
:
18704 SetConsoleCtrlHandler (NULL
, TRUE
);
18711 case CTRL_LOGOFF_EVENT
:
18712 case CTRL_SHUTDOWN_EVENT
:
18716 SetConsoleCtrlHandler (NULL
, TRUE
);
18724 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18726 if (callback
== NULL
)
18728 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18732 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18738 void sigHandler_default (int sig
)
18742 signal (sig
, NULL
);
18745 void sigHandler_benchmark (int sig
)
18749 signal (sig
, NULL
);
18752 void hc_signal (void (callback
) (int))
18754 if (callback
== NULL
) callback
= SIG_DFL
;
18756 signal (SIGINT
, callback
);
18757 signal (SIGTERM
, callback
);
18758 signal (SIGABRT
, callback
);
18763 void status_display ();
18765 void *thread_keypress (void *p
)
18767 int benchmark
= *((int *) p
);
18769 uint quiet
= data
.quiet
;
18773 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18775 int ch
= tty_getchar();
18777 if (ch
== -1) break;
18779 if (ch
== 0) continue;
18785 hc_thread_mutex_lock (mux_display
);
18800 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18801 if (quiet
== 0) fflush (stdout
);
18813 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18814 if (quiet
== 0) fflush (stdout
);
18826 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18827 if (quiet
== 0) fflush (stdout
);
18839 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18840 if (quiet
== 0) fflush (stdout
);
18848 if (benchmark
== 1) break;
18850 stop_at_checkpoint ();
18854 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18855 if (quiet
== 0) fflush (stdout
);
18863 if (benchmark
== 1)
18875 hc_thread_mutex_unlock (mux_display
);
18887 bool class_num (char c
)
18889 return ((c
>= '0') && (c
<= '9'));
18892 bool class_lower (char c
)
18894 return ((c
>= 'a') && (c
<= 'z'));
18897 bool class_upper (char c
)
18899 return ((c
>= 'A') && (c
<= 'Z'));
18902 bool class_alpha (char c
)
18904 return (class_lower (c
) || class_upper (c
));
18907 char conv_ctoi (char c
)
18913 else if (class_upper (c
))
18915 return c
- 'A' + (char) 10;
18918 return (char) (-1);
18921 char conv_itoc (char c
)
18929 return c
+ 'A' - (char) 10;
18932 return (char) (-1);
18939 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18940 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18941 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18942 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18943 #define MAX_KERNEL_RULES 255
18944 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18945 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18946 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18948 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18949 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18950 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18951 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18953 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
18958 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
18960 switch (rule_buf
[rule_pos
])
18966 case RULE_OP_MANGLE_NOOP
:
18967 SET_NAME (rule
, rule_buf
[rule_pos
]);
18970 case RULE_OP_MANGLE_LREST
:
18971 SET_NAME (rule
, rule_buf
[rule_pos
]);
18974 case RULE_OP_MANGLE_UREST
:
18975 SET_NAME (rule
, rule_buf
[rule_pos
]);
18978 case RULE_OP_MANGLE_LREST_UFIRST
:
18979 SET_NAME (rule
, rule_buf
[rule_pos
]);
18982 case RULE_OP_MANGLE_UREST_LFIRST
:
18983 SET_NAME (rule
, rule_buf
[rule_pos
]);
18986 case RULE_OP_MANGLE_TREST
:
18987 SET_NAME (rule
, rule_buf
[rule_pos
]);
18990 case RULE_OP_MANGLE_TOGGLE_AT
:
18991 SET_NAME (rule
, rule_buf
[rule_pos
]);
18992 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18995 case RULE_OP_MANGLE_REVERSE
:
18996 SET_NAME (rule
, rule_buf
[rule_pos
]);
18999 case RULE_OP_MANGLE_DUPEWORD
:
19000 SET_NAME (rule
, rule_buf
[rule_pos
]);
19003 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19004 SET_NAME (rule
, rule_buf
[rule_pos
]);
19005 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19008 case RULE_OP_MANGLE_REFLECT
:
19009 SET_NAME (rule
, rule_buf
[rule_pos
]);
19012 case RULE_OP_MANGLE_ROTATE_LEFT
:
19013 SET_NAME (rule
, rule_buf
[rule_pos
]);
19016 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19017 SET_NAME (rule
, rule_buf
[rule_pos
]);
19020 case RULE_OP_MANGLE_APPEND
:
19021 SET_NAME (rule
, rule_buf
[rule_pos
]);
19022 SET_P0 (rule
, rule_buf
[rule_pos
]);
19025 case RULE_OP_MANGLE_PREPEND
:
19026 SET_NAME (rule
, rule_buf
[rule_pos
]);
19027 SET_P0 (rule
, rule_buf
[rule_pos
]);
19030 case RULE_OP_MANGLE_DELETE_FIRST
:
19031 SET_NAME (rule
, rule_buf
[rule_pos
]);
19034 case RULE_OP_MANGLE_DELETE_LAST
:
19035 SET_NAME (rule
, rule_buf
[rule_pos
]);
19038 case RULE_OP_MANGLE_DELETE_AT
:
19039 SET_NAME (rule
, rule_buf
[rule_pos
]);
19040 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19043 case RULE_OP_MANGLE_EXTRACT
:
19044 SET_NAME (rule
, rule_buf
[rule_pos
]);
19045 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19046 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19049 case RULE_OP_MANGLE_OMIT
:
19050 SET_NAME (rule
, rule_buf
[rule_pos
]);
19051 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19052 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19055 case RULE_OP_MANGLE_INSERT
:
19056 SET_NAME (rule
, rule_buf
[rule_pos
]);
19057 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19058 SET_P1 (rule
, rule_buf
[rule_pos
]);
19061 case RULE_OP_MANGLE_OVERSTRIKE
:
19062 SET_NAME (rule
, rule_buf
[rule_pos
]);
19063 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19064 SET_P1 (rule
, rule_buf
[rule_pos
]);
19067 case RULE_OP_MANGLE_TRUNCATE_AT
:
19068 SET_NAME (rule
, rule_buf
[rule_pos
]);
19069 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19072 case RULE_OP_MANGLE_REPLACE
:
19073 SET_NAME (rule
, rule_buf
[rule_pos
]);
19074 SET_P0 (rule
, rule_buf
[rule_pos
]);
19075 SET_P1 (rule
, rule_buf
[rule_pos
]);
19078 case RULE_OP_MANGLE_PURGECHAR
:
19082 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19086 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19087 SET_NAME (rule
, rule_buf
[rule_pos
]);
19088 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19091 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19092 SET_NAME (rule
, rule_buf
[rule_pos
]);
19093 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19096 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19097 SET_NAME (rule
, rule_buf
[rule_pos
]);
19100 case RULE_OP_MANGLE_SWITCH_FIRST
:
19101 SET_NAME (rule
, rule_buf
[rule_pos
]);
19104 case RULE_OP_MANGLE_SWITCH_LAST
:
19105 SET_NAME (rule
, rule_buf
[rule_pos
]);
19108 case RULE_OP_MANGLE_SWITCH_AT
:
19109 SET_NAME (rule
, rule_buf
[rule_pos
]);
19110 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19111 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19114 case RULE_OP_MANGLE_CHR_SHIFTL
:
19115 SET_NAME (rule
, rule_buf
[rule_pos
]);
19116 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19119 case RULE_OP_MANGLE_CHR_SHIFTR
:
19120 SET_NAME (rule
, rule_buf
[rule_pos
]);
19121 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19124 case RULE_OP_MANGLE_CHR_INCR
:
19125 SET_NAME (rule
, rule_buf
[rule_pos
]);
19126 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19129 case RULE_OP_MANGLE_CHR_DECR
:
19130 SET_NAME (rule
, rule_buf
[rule_pos
]);
19131 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19134 case RULE_OP_MANGLE_REPLACE_NP1
:
19135 SET_NAME (rule
, rule_buf
[rule_pos
]);
19136 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19139 case RULE_OP_MANGLE_REPLACE_NM1
:
19140 SET_NAME (rule
, rule_buf
[rule_pos
]);
19141 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19144 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19145 SET_NAME (rule
, rule_buf
[rule_pos
]);
19146 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19149 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19150 SET_NAME (rule
, rule_buf
[rule_pos
]);
19151 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19154 case RULE_OP_MANGLE_TITLE
:
19155 SET_NAME (rule
, rule_buf
[rule_pos
]);
19164 if (rule_pos
< rule_len
) return (-1);
19169 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19173 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19177 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19181 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19185 case RULE_OP_MANGLE_NOOP
:
19186 rule_buf
[rule_pos
] = rule_cmd
;
19189 case RULE_OP_MANGLE_LREST
:
19190 rule_buf
[rule_pos
] = rule_cmd
;
19193 case RULE_OP_MANGLE_UREST
:
19194 rule_buf
[rule_pos
] = rule_cmd
;
19197 case RULE_OP_MANGLE_LREST_UFIRST
:
19198 rule_buf
[rule_pos
] = rule_cmd
;
19201 case RULE_OP_MANGLE_UREST_LFIRST
:
19202 rule_buf
[rule_pos
] = rule_cmd
;
19205 case RULE_OP_MANGLE_TREST
:
19206 rule_buf
[rule_pos
] = rule_cmd
;
19209 case RULE_OP_MANGLE_TOGGLE_AT
:
19210 rule_buf
[rule_pos
] = rule_cmd
;
19211 GET_P0_CONV (rule
);
19214 case RULE_OP_MANGLE_REVERSE
:
19215 rule_buf
[rule_pos
] = rule_cmd
;
19218 case RULE_OP_MANGLE_DUPEWORD
:
19219 rule_buf
[rule_pos
] = rule_cmd
;
19222 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19223 rule_buf
[rule_pos
] = rule_cmd
;
19224 GET_P0_CONV (rule
);
19227 case RULE_OP_MANGLE_REFLECT
:
19228 rule_buf
[rule_pos
] = rule_cmd
;
19231 case RULE_OP_MANGLE_ROTATE_LEFT
:
19232 rule_buf
[rule_pos
] = rule_cmd
;
19235 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19236 rule_buf
[rule_pos
] = rule_cmd
;
19239 case RULE_OP_MANGLE_APPEND
:
19240 rule_buf
[rule_pos
] = rule_cmd
;
19244 case RULE_OP_MANGLE_PREPEND
:
19245 rule_buf
[rule_pos
] = rule_cmd
;
19249 case RULE_OP_MANGLE_DELETE_FIRST
:
19250 rule_buf
[rule_pos
] = rule_cmd
;
19253 case RULE_OP_MANGLE_DELETE_LAST
:
19254 rule_buf
[rule_pos
] = rule_cmd
;
19257 case RULE_OP_MANGLE_DELETE_AT
:
19258 rule_buf
[rule_pos
] = rule_cmd
;
19259 GET_P0_CONV (rule
);
19262 case RULE_OP_MANGLE_EXTRACT
:
19263 rule_buf
[rule_pos
] = rule_cmd
;
19264 GET_P0_CONV (rule
);
19265 GET_P1_CONV (rule
);
19268 case RULE_OP_MANGLE_OMIT
:
19269 rule_buf
[rule_pos
] = rule_cmd
;
19270 GET_P0_CONV (rule
);
19271 GET_P1_CONV (rule
);
19274 case RULE_OP_MANGLE_INSERT
:
19275 rule_buf
[rule_pos
] = rule_cmd
;
19276 GET_P0_CONV (rule
);
19280 case RULE_OP_MANGLE_OVERSTRIKE
:
19281 rule_buf
[rule_pos
] = rule_cmd
;
19282 GET_P0_CONV (rule
);
19286 case RULE_OP_MANGLE_TRUNCATE_AT
:
19287 rule_buf
[rule_pos
] = rule_cmd
;
19288 GET_P0_CONV (rule
);
19291 case RULE_OP_MANGLE_REPLACE
:
19292 rule_buf
[rule_pos
] = rule_cmd
;
19297 case RULE_OP_MANGLE_PURGECHAR
:
19301 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19305 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19306 rule_buf
[rule_pos
] = rule_cmd
;
19307 GET_P0_CONV (rule
);
19310 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19311 rule_buf
[rule_pos
] = rule_cmd
;
19312 GET_P0_CONV (rule
);
19315 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19316 rule_buf
[rule_pos
] = rule_cmd
;
19319 case RULE_OP_MANGLE_SWITCH_FIRST
:
19320 rule_buf
[rule_pos
] = rule_cmd
;
19323 case RULE_OP_MANGLE_SWITCH_LAST
:
19324 rule_buf
[rule_pos
] = rule_cmd
;
19327 case RULE_OP_MANGLE_SWITCH_AT
:
19328 rule_buf
[rule_pos
] = rule_cmd
;
19329 GET_P0_CONV (rule
);
19330 GET_P1_CONV (rule
);
19333 case RULE_OP_MANGLE_CHR_SHIFTL
:
19334 rule_buf
[rule_pos
] = rule_cmd
;
19335 GET_P0_CONV (rule
);
19338 case RULE_OP_MANGLE_CHR_SHIFTR
:
19339 rule_buf
[rule_pos
] = rule_cmd
;
19340 GET_P0_CONV (rule
);
19343 case RULE_OP_MANGLE_CHR_INCR
:
19344 rule_buf
[rule_pos
] = rule_cmd
;
19345 GET_P0_CONV (rule
);
19348 case RULE_OP_MANGLE_CHR_DECR
:
19349 rule_buf
[rule_pos
] = rule_cmd
;
19350 GET_P0_CONV (rule
);
19353 case RULE_OP_MANGLE_REPLACE_NP1
:
19354 rule_buf
[rule_pos
] = rule_cmd
;
19355 GET_P0_CONV (rule
);
19358 case RULE_OP_MANGLE_REPLACE_NM1
:
19359 rule_buf
[rule_pos
] = rule_cmd
;
19360 GET_P0_CONV (rule
);
19363 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19364 rule_buf
[rule_pos
] = rule_cmd
;
19365 GET_P0_CONV (rule
);
19368 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19369 rule_buf
[rule_pos
] = rule_cmd
;
19370 GET_P0_CONV (rule
);
19373 case RULE_OP_MANGLE_TITLE
:
19374 rule_buf
[rule_pos
] = rule_cmd
;
19378 return rule_pos
- 1;
19396 * CPU rules : this is from hashcat sources, cpu based rules
19399 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19400 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19402 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19403 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19404 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19406 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19407 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19408 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19410 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19414 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19419 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19423 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19428 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19432 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19437 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19442 for (l
= 0; l
< arr_len
; l
++)
19444 r
= arr_len
- 1 - l
;
19448 MANGLE_SWITCH (arr
, l
, r
);
19454 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19456 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19458 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19460 return (arr_len
* 2);
19463 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19465 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19467 int orig_len
= arr_len
;
19471 for (i
= 0; i
< times
; i
++)
19473 memcpy (&arr
[arr_len
], arr
, orig_len
);
19475 arr_len
+= orig_len
;
19481 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19483 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19485 mangle_double (arr
, arr_len
);
19487 mangle_reverse (arr
+ arr_len
, arr_len
);
19489 return (arr_len
* 2);
19492 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19497 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19499 MANGLE_SWITCH (arr
, l
, r
);
19505 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19510 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19512 MANGLE_SWITCH (arr
, l
, r
);
19518 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19520 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19524 return (arr_len
+ 1);
19527 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19529 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19533 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19535 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19540 return (arr_len
+ 1);
19543 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19545 if (upos
>= arr_len
) return (arr_len
);
19549 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19551 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19554 return (arr_len
- 1);
19557 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19559 if (upos
>= arr_len
) return (arr_len
);
19561 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19565 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19567 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19573 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19575 if (upos
>= arr_len
) return (arr_len
);
19577 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19581 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19583 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19586 return (arr_len
- ulen
);
19589 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19591 if (upos
>= arr_len
) return (arr_len
);
19593 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19597 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19599 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19604 return (arr_len
+ 1);
19607 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
)
19609 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19611 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19613 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19615 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19617 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19619 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19621 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19623 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19625 return (arr_len
+ arr2_cpy
);
19628 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19630 if (upos
>= arr_len
) return (arr_len
);
19637 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19639 if (upos
>= arr_len
) return (arr_len
);
19641 memset (arr
+ upos
, 0, arr_len
- upos
);
19646 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19650 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19652 if (arr
[arr_pos
] != oldc
) continue;
19654 arr
[arr_pos
] = newc
;
19660 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19666 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19668 if (arr
[arr_pos
] == c
) continue;
19670 arr
[ret_len
] = arr
[arr_pos
];
19678 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19680 if (ulen
> arr_len
) return (arr_len
);
19682 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19686 memcpy (cs
, arr
, ulen
);
19690 for (i
= 0; i
< ulen
; i
++)
19694 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19700 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19702 if (ulen
> arr_len
) return (arr_len
);
19704 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19706 int upos
= arr_len
- ulen
;
19710 for (i
= 0; i
< ulen
; i
++)
19712 char c
= arr
[upos
+ i
];
19714 arr_len
= mangle_append (arr
, arr_len
, c
);
19720 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19722 if ( arr_len
== 0) return (arr_len
);
19723 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19725 char c
= arr
[upos
];
19729 for (i
= 0; i
< ulen
; i
++)
19731 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19737 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19739 if ( arr_len
== 0) return (arr_len
);
19740 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19744 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19746 int new_pos
= arr_pos
* 2;
19748 arr
[new_pos
] = arr
[arr_pos
];
19750 arr
[new_pos
+ 1] = arr
[arr_pos
];
19753 return (arr_len
* 2);
19756 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19758 if (upos
>= arr_len
) return (arr_len
);
19759 if (upos2
>= arr_len
) return (arr_len
);
19761 MANGLE_SWITCH (arr
, upos
, upos2
);
19766 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19768 MANGLE_SWITCH (arr
, upos
, upos2
);
19773 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19775 if (upos
>= arr_len
) return (arr_len
);
19782 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19784 if (upos
>= arr_len
) return (arr_len
);
19791 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19793 if (upos
>= arr_len
) return (arr_len
);
19800 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19802 if (upos
>= arr_len
) return (arr_len
);
19809 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19811 int upper_next
= 1;
19815 for (pos
= 0; pos
< arr_len
; pos
++)
19817 if (arr
[pos
] == ' ')
19828 MANGLE_UPPER_AT (arr
, pos
);
19832 MANGLE_LOWER_AT (arr
, pos
);
19839 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19841 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19845 uint32_t rule_pos
= 0;
19847 for (j
= 0; j
< rp_gen_num
; j
++)
19854 switch ((char) get_random_num (0, 9))
19857 r
= get_random_num (0, sizeof (grp_op_nop
));
19858 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19862 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19863 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19864 p1
= get_random_num (0, sizeof (grp_pos
));
19865 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19869 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19870 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19871 p1
= get_random_num (1, 6);
19872 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19876 r
= get_random_num (0, sizeof (grp_op_chr
));
19877 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19878 p1
= get_random_num (0x20, 0x7e);
19879 rule_buf
[rule_pos
++] = (char) p1
;
19883 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19884 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19885 p1
= get_random_num (0x20, 0x7e);
19886 rule_buf
[rule_pos
++] = (char) p1
;
19887 p2
= get_random_num (0x20, 0x7e);
19889 p2
= get_random_num (0x20, 0x7e);
19890 rule_buf
[rule_pos
++] = (char) p2
;
19894 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19895 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19896 p1
= get_random_num (0, sizeof (grp_pos
));
19897 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19898 p2
= get_random_num (0x20, 0x7e);
19899 rule_buf
[rule_pos
++] = (char) p2
;
19903 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19904 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19905 p1
= get_random_num (0, sizeof (grp_pos
));
19906 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19907 p2
= get_random_num (0, sizeof (grp_pos
));
19909 p2
= get_random_num (0, sizeof (grp_pos
));
19910 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19914 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19915 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19916 p1
= get_random_num (0, sizeof (grp_pos
));
19917 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19918 p2
= get_random_num (1, sizeof (grp_pos
));
19920 p2
= get_random_num (1, sizeof (grp_pos
));
19921 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19925 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19926 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19927 p1
= get_random_num (0, sizeof (grp_pos
));
19928 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19929 p2
= get_random_num (1, sizeof (grp_pos
));
19930 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19931 p3
= get_random_num (0, sizeof (grp_pos
));
19932 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19940 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19942 char mem
[BLOCK_SIZE
];
19944 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19946 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19948 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19950 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19952 int out_len
= in_len
;
19953 int mem_len
= in_len
;
19955 memcpy (out
, in
, out_len
);
19959 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19961 int upos
; int upos2
;
19964 switch (rule
[rule_pos
])
19969 case RULE_OP_MANGLE_NOOP
:
19972 case RULE_OP_MANGLE_LREST
:
19973 out_len
= mangle_lrest (out
, out_len
);
19976 case RULE_OP_MANGLE_UREST
:
19977 out_len
= mangle_urest (out
, out_len
);
19980 case RULE_OP_MANGLE_LREST_UFIRST
:
19981 out_len
= mangle_lrest (out
, out_len
);
19982 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19985 case RULE_OP_MANGLE_UREST_LFIRST
:
19986 out_len
= mangle_urest (out
, out_len
);
19987 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19990 case RULE_OP_MANGLE_TREST
:
19991 out_len
= mangle_trest (out
, out_len
);
19994 case RULE_OP_MANGLE_TOGGLE_AT
:
19995 NEXT_RULEPOS (rule_pos
);
19996 NEXT_RPTOI (rule
, rule_pos
, upos
);
19997 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20000 case RULE_OP_MANGLE_REVERSE
:
20001 out_len
= mangle_reverse (out
, out_len
);
20004 case RULE_OP_MANGLE_DUPEWORD
:
20005 out_len
= mangle_double (out
, out_len
);
20008 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20009 NEXT_RULEPOS (rule_pos
);
20010 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20011 out_len
= mangle_double_times (out
, out_len
, ulen
);
20014 case RULE_OP_MANGLE_REFLECT
:
20015 out_len
= mangle_reflect (out
, out_len
);
20018 case RULE_OP_MANGLE_ROTATE_LEFT
:
20019 mangle_rotate_left (out
, out_len
);
20022 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20023 mangle_rotate_right (out
, out_len
);
20026 case RULE_OP_MANGLE_APPEND
:
20027 NEXT_RULEPOS (rule_pos
);
20028 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20031 case RULE_OP_MANGLE_PREPEND
:
20032 NEXT_RULEPOS (rule_pos
);
20033 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20036 case RULE_OP_MANGLE_DELETE_FIRST
:
20037 out_len
= mangle_delete_at (out
, out_len
, 0);
20040 case RULE_OP_MANGLE_DELETE_LAST
:
20041 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20044 case RULE_OP_MANGLE_DELETE_AT
:
20045 NEXT_RULEPOS (rule_pos
);
20046 NEXT_RPTOI (rule
, rule_pos
, upos
);
20047 out_len
= mangle_delete_at (out
, out_len
, upos
);
20050 case RULE_OP_MANGLE_EXTRACT
:
20051 NEXT_RULEPOS (rule_pos
);
20052 NEXT_RPTOI (rule
, rule_pos
, upos
);
20053 NEXT_RULEPOS (rule_pos
);
20054 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20055 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20058 case RULE_OP_MANGLE_OMIT
:
20059 NEXT_RULEPOS (rule_pos
);
20060 NEXT_RPTOI (rule
, rule_pos
, upos
);
20061 NEXT_RULEPOS (rule_pos
);
20062 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20063 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20066 case RULE_OP_MANGLE_INSERT
:
20067 NEXT_RULEPOS (rule_pos
);
20068 NEXT_RPTOI (rule
, rule_pos
, upos
);
20069 NEXT_RULEPOS (rule_pos
);
20070 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20073 case RULE_OP_MANGLE_OVERSTRIKE
:
20074 NEXT_RULEPOS (rule_pos
);
20075 NEXT_RPTOI (rule
, rule_pos
, upos
);
20076 NEXT_RULEPOS (rule_pos
);
20077 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20080 case RULE_OP_MANGLE_TRUNCATE_AT
:
20081 NEXT_RULEPOS (rule_pos
);
20082 NEXT_RPTOI (rule
, rule_pos
, upos
);
20083 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20086 case RULE_OP_MANGLE_REPLACE
:
20087 NEXT_RULEPOS (rule_pos
);
20088 NEXT_RULEPOS (rule_pos
);
20089 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20092 case RULE_OP_MANGLE_PURGECHAR
:
20093 NEXT_RULEPOS (rule_pos
);
20094 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20097 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20101 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20102 NEXT_RULEPOS (rule_pos
);
20103 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20104 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20107 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20108 NEXT_RULEPOS (rule_pos
);
20109 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20110 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20113 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20114 out_len
= mangle_dupechar (out
, out_len
);
20117 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20118 NEXT_RULEPOS (rule_pos
);
20119 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20120 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20123 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20124 NEXT_RULEPOS (rule_pos
);
20125 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20126 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20129 case RULE_OP_MANGLE_SWITCH_FIRST
:
20130 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20133 case RULE_OP_MANGLE_SWITCH_LAST
:
20134 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20137 case RULE_OP_MANGLE_SWITCH_AT
:
20138 NEXT_RULEPOS (rule_pos
);
20139 NEXT_RPTOI (rule
, rule_pos
, upos
);
20140 NEXT_RULEPOS (rule_pos
);
20141 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20142 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20145 case RULE_OP_MANGLE_CHR_SHIFTL
:
20146 NEXT_RULEPOS (rule_pos
);
20147 NEXT_RPTOI (rule
, rule_pos
, upos
);
20148 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20151 case RULE_OP_MANGLE_CHR_SHIFTR
:
20152 NEXT_RULEPOS (rule_pos
);
20153 NEXT_RPTOI (rule
, rule_pos
, upos
);
20154 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20157 case RULE_OP_MANGLE_CHR_INCR
:
20158 NEXT_RULEPOS (rule_pos
);
20159 NEXT_RPTOI (rule
, rule_pos
, upos
);
20160 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20163 case RULE_OP_MANGLE_CHR_DECR
:
20164 NEXT_RULEPOS (rule_pos
);
20165 NEXT_RPTOI (rule
, rule_pos
, upos
);
20166 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20169 case RULE_OP_MANGLE_REPLACE_NP1
:
20170 NEXT_RULEPOS (rule_pos
);
20171 NEXT_RPTOI (rule
, rule_pos
, upos
);
20172 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20175 case RULE_OP_MANGLE_REPLACE_NM1
:
20176 NEXT_RULEPOS (rule_pos
);
20177 NEXT_RPTOI (rule
, rule_pos
, upos
);
20178 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20181 case RULE_OP_MANGLE_TITLE
:
20182 out_len
= mangle_title (out
, out_len
);
20185 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20186 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20187 NEXT_RULEPOS (rule_pos
);
20188 NEXT_RPTOI (rule
, rule_pos
, upos
);
20189 NEXT_RULEPOS (rule_pos
);
20190 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20191 NEXT_RULEPOS (rule_pos
);
20192 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20193 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20196 case RULE_OP_MANGLE_APPEND_MEMORY
:
20197 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20198 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20199 memcpy (out
+ out_len
, mem
, mem_len
);
20200 out_len
+= mem_len
;
20203 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20204 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20205 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20206 memcpy (mem
+ mem_len
, out
, out_len
);
20207 out_len
+= mem_len
;
20208 memcpy (out
, mem
, out_len
);
20211 case RULE_OP_MEMORIZE_WORD
:
20212 memcpy (mem
, out
, out_len
);
20216 case RULE_OP_REJECT_LESS
:
20217 NEXT_RULEPOS (rule_pos
);
20218 NEXT_RPTOI (rule
, rule_pos
, upos
);
20219 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20222 case RULE_OP_REJECT_GREATER
:
20223 NEXT_RULEPOS (rule_pos
);
20224 NEXT_RPTOI (rule
, rule_pos
, upos
);
20225 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20228 case RULE_OP_REJECT_CONTAIN
:
20229 NEXT_RULEPOS (rule_pos
);
20230 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20233 case RULE_OP_REJECT_NOT_CONTAIN
:
20234 NEXT_RULEPOS (rule_pos
);
20235 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20238 case RULE_OP_REJECT_EQUAL_FIRST
:
20239 NEXT_RULEPOS (rule_pos
);
20240 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20243 case RULE_OP_REJECT_EQUAL_LAST
:
20244 NEXT_RULEPOS (rule_pos
);
20245 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20248 case RULE_OP_REJECT_EQUAL_AT
:
20249 NEXT_RULEPOS (rule_pos
);
20250 NEXT_RPTOI (rule
, rule_pos
, upos
);
20251 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20252 NEXT_RULEPOS (rule_pos
);
20253 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20256 case RULE_OP_REJECT_CONTAINS
:
20257 NEXT_RULEPOS (rule_pos
);
20258 NEXT_RPTOI (rule
, rule_pos
, upos
);
20259 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20260 NEXT_RULEPOS (rule_pos
);
20261 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20262 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20265 case RULE_OP_REJECT_MEMORY
:
20266 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20270 return (RULE_RC_SYNTAX_ERROR
);
20275 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);