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))
17 #define GET_ACCEL(x) GPU_ACCEL_NV_ ## x
18 #define GET_LOOPS(x) GPU_LOOPS_NV_ ## x
20 #define GET_ACCEL(x) GPU_ACCEL_AMD_ ## x
21 #define GET_LOOPS(x) GPU_LOOPS_AMD_ ## x
28 uint32_t rotl32 (const uint32_t a
, const uint n
)
30 return ((a
<< n
) | (a
>> (32 - n
)));
33 uint32_t rotr32 (const uint32_t a
, const uint n
)
35 return ((a
>> n
) | (a
<< (32 - n
)));
38 uint64_t rotl64 (const uint64_t a
, const uint n
)
40 return ((a
<< n
) | (a
>> (64 - n
)));
43 uint64_t rotr64 (const uint64_t a
, const uint n
)
45 return ((a
>> n
) | (a
<< (64 - n
)));
49 * ciphers for use on cpu
56 * hashes for use on cpu
60 #include "cpu-sha256.c"
68 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
74 for (int i
= 0; i
< last_len
; i
++)
84 int max_len
= (int) sizeof (s
);
86 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
88 if (len
> max_len
) len
= max_len
;
90 fwrite (s
, len
, 1, fp
);
97 void log_out_nn (FILE *fp
, const char *fmt
, ...)
99 if (SUPPRESS_OUTPUT
) return;
105 log_final (fp
, fmt
, ap
);
110 void log_info_nn (const char *fmt
, ...)
112 if (SUPPRESS_OUTPUT
) return;
118 log_final (stdout
, fmt
, ap
);
123 void log_error_nn (const char *fmt
, ...)
125 if (SUPPRESS_OUTPUT
) return;
131 log_final (stderr
, fmt
, ap
);
136 void log_out (FILE *fp
, const char *fmt
, ...)
138 if (SUPPRESS_OUTPUT
) return;
144 log_final (fp
, fmt
, ap
);
153 void log_info (const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (stdout
, fmt
, ap
);
165 fputc ('\n', stdout
);
170 void log_error (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
174 fputc ('\n', stderr
);
175 fputc ('\n', stderr
);
181 log_final (stderr
, fmt
, ap
);
185 fputc ('\n', stderr
);
186 fputc ('\n', stderr
);
195 uint
byte_swap_32 (const uint n
)
197 return (n
& 0xff000000) >> 24
198 | (n
& 0x00ff0000) >> 8
199 | (n
& 0x0000ff00) << 8
200 | (n
& 0x000000ff) << 24;
203 uint64_t byte_swap_64 (const uint64_t n
)
205 return (n
& 0xff00000000000000ULL
) >> 56
206 | (n
& 0x00ff000000000000ULL
) >> 40
207 | (n
& 0x0000ff0000000000ULL
) >> 24
208 | (n
& 0x000000ff00000000ULL
) >> 8
209 | (n
& 0x00000000ff000000ULL
) << 8
210 | (n
& 0x0000000000ff0000ULL
) << 24
211 | (n
& 0x000000000000ff00ULL
) << 40
212 | (n
& 0x00000000000000ffULL
) << 56;
215 char int_to_base32 (const char c
)
217 static const char tbl
[0x20] =
219 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
220 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 return tbl
[(const uint8_t) c
];
226 char base32_to_int (const char c
)
228 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
229 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
234 char int_to_itoa32 (const char c
)
236 static const char tbl
[0x20] =
238 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
239 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 return tbl
[(const uint8_t) c
];
245 char itoa32_to_int (const char c
)
247 if ((c
>= '0') && (c
<= '9')) return c
- '0';
248 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
253 char int_to_itoa64 (const char c
)
255 static const char tbl
[0x40] =
257 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
258 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
259 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
260 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 return tbl
[(const uint8_t) c
];
266 char itoa64_to_int (const char c
)
268 static const char tbl
[0x100] =
270 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
271 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
272 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
273 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
274 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
275 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
276 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
277 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
278 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
279 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
280 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
281 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
282 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
283 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
284 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
285 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 return tbl
[(const uint8_t) c
];
291 char int_to_base64 (const char c
)
293 static const char tbl
[0x40] =
295 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
296 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
297 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
298 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 return tbl
[(const uint8_t) c
];
304 char base64_to_int (const char c
)
306 static const char tbl
[0x100] =
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
311 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
313 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
315 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 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,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
323 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 return tbl
[(const uint8_t) c
];
329 char int_to_bf64 (const char c
)
331 static const char tbl
[0x40] =
333 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
334 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
335 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
336 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 return tbl
[(const uint8_t) c
];
342 char bf64_to_int (const char c
)
344 static const char tbl
[0x100] =
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
349 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
351 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
353 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 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,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
360 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
361 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 return tbl
[(const uint8_t) c
];
367 char int_to_lotus64 (const char c
)
369 if (c
< 10) return '0' + c
;
370 else if (c
< 36) return 'A' + c
- 10;
371 else if (c
< 62) return 'a' + c
- 36;
372 else if (c
== 62) return '+';
373 else if (c
== 63) return '/';
378 char lotus64_to_int (const char c
)
380 if ((c
>= '0') && (c
<= '9')) return c
- '0';
381 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
382 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
383 else if (c
== '+') return 62;
384 else if (c
== '/') return 63;
390 int base32_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
392 char *in_ptr
= in_buf
;
394 char *out_ptr
= out_buf
;
396 for (int i
= 0; i
< in_len
; i
+= 8)
398 char out_val0
= f (in_ptr
[0] & 0x7f);
399 char out_val1
= f (in_ptr
[1] & 0x7f);
400 char out_val2
= f (in_ptr
[2] & 0x7f);
401 char out_val3
= f (in_ptr
[3] & 0x7f);
402 char out_val4
= f (in_ptr
[4] & 0x7f);
403 char out_val5
= f (in_ptr
[5] & 0x7f);
404 char out_val6
= f (in_ptr
[6] & 0x7f);
405 char out_val7
= f (in_ptr
[7] & 0x7f);
407 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
408 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
409 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
410 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
411 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
417 for (int i
= 0; i
< in_len
; i
++)
419 if (in_buf
[i
] != '=') continue;
424 int out_len
= (in_len
* 5) / 8;
429 int base32_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
431 char *in_ptr
= in_buf
;
433 char *out_ptr
= out_buf
;
435 for (int i
= 0; i
< in_len
; i
+= 5)
437 char out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
438 char out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
439 char out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
440 char out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
441 char out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
442 char out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
443 char out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
444 char out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
446 out_ptr
[0] = out_val0
& 0x7f;
447 out_ptr
[1] = out_val1
& 0x7f;
448 out_ptr
[2] = out_val2
& 0x7f;
449 out_ptr
[3] = out_val3
& 0x7f;
450 out_ptr
[4] = out_val4
& 0x7f;
451 out_ptr
[5] = out_val5
& 0x7f;
452 out_ptr
[6] = out_val6
& 0x7f;
453 out_ptr
[7] = out_val7
& 0x7f;
459 int out_len
= (in_len
* 8) / 5;
461 for (int i
= 0; i
< (7 - (in_len
% 7)); i
++)
465 out_buf
[out_len
] = '=';
471 int base64_decode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
473 char *in_ptr
= in_buf
;
475 char *out_ptr
= out_buf
;
477 for (int i
= 0; i
< in_len
; i
+= 4)
479 char out_val0
= f (in_ptr
[0] & 0x7f);
480 char out_val1
= f (in_ptr
[1] & 0x7f);
481 char out_val2
= f (in_ptr
[2] & 0x7f);
482 char out_val3
= f (in_ptr
[3] & 0x7f);
484 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
485 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
486 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
492 for (int i
= 0; i
< in_len
; i
++)
494 if (in_buf
[i
] != '=') continue;
499 int out_len
= (in_len
* 6) / 8;
504 int base64_encode (char (*f
) (const char), char *in_buf
, int in_len
, char *out_buf
)
506 char *in_ptr
= in_buf
;
508 char *out_ptr
= out_buf
;
510 for (int i
= 0; i
< in_len
; i
+= 3)
512 char out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
513 char out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
514 char out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
515 char out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
517 out_ptr
[0] = out_val0
& 0x7f;
518 out_ptr
[1] = out_val1
& 0x7f;
519 out_ptr
[2] = out_val2
& 0x7f;
520 out_ptr
[3] = out_val3
& 0x7f;
526 int out_len
= (in_len
* 8) / 6;
528 for (int i
= 0; i
< (3 - (in_len
% 3)); i
++)
532 out_buf
[out_len
] = '=';
538 static void AES128_decrypt_cbc (const uint key
[4], const uint iv
[4], const uint in
[16], uint out
[16])
542 AES_set_decrypt_key ((unsigned char *) key
, 128, &skey
);
551 for (int i
= 0; i
< 16; i
+= 4)
561 AES_decrypt (&skey
, (char *) _in
, (char *) _out
);
568 out
[i
+ 0] = _out
[0];
569 out
[i
+ 1] = _out
[1];
570 out
[i
+ 2] = _out
[2];
571 out
[i
+ 3] = _out
[3];
580 static void juniper_decrypt_hash (char *in
, char *out
)
584 char base64_buf
[100];
586 memset (base64_buf
, 0, sizeof (base64_buf
));
588 base64_decode (base64_to_int
, in
, DISPLAY_LEN_MIN_501
, base64_buf
);
592 uint juniper_iv
[4] = { 0 };
594 memcpy (juniper_iv
, base64_buf
, 12);
596 memcpy (out
, juniper_iv
, 12);
602 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
603 juniper_key
[1] = byte_swap_32 (0x8df91059);
604 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
605 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
609 uint
*in_ptr
= (uint
*) (base64_buf
+ 12);
610 uint
*out_ptr
= (uint
*) (out
+ 12);
612 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
615 uint
is_valid_hex_char (const char c
)
617 if ((c
>= '0') && (c
<= '9')) return 1;
618 if ((c
>= 'A') && (c
<= 'F')) return 1;
619 if ((c
>= 'a') && (c
<= 'f')) return 1;
624 char hex_convert (const char c
)
626 return (c
& 15) + (c
>> 6) * 9;
629 char hex_to_char (const char hex
[2])
633 v
|= (hex_convert (hex
[1]) << 0);
634 v
|= (hex_convert (hex
[0]) << 4);
639 uint
hex_to_uint (const char hex
[8])
643 v
|= hex_convert (hex
[7]) << 0;
644 v
|= hex_convert (hex
[6]) << 4;
645 v
|= hex_convert (hex
[5]) << 8;
646 v
|= hex_convert (hex
[4]) << 12;
647 v
|= hex_convert (hex
[3]) << 16;
648 v
|= hex_convert (hex
[2]) << 20;
649 v
|= hex_convert (hex
[1]) << 24;
650 v
|= hex_convert (hex
[0]) << 28;
655 uint64_t hex_to_uint64_t (const char hex
[16])
659 v
|= ((uint64_t) hex_convert (hex
[15]) << 0);
660 v
|= ((uint64_t) hex_convert (hex
[14]) << 4);
661 v
|= ((uint64_t) hex_convert (hex
[13]) << 8);
662 v
|= ((uint64_t) hex_convert (hex
[12]) << 12);
663 v
|= ((uint64_t) hex_convert (hex
[11]) << 16);
664 v
|= ((uint64_t) hex_convert (hex
[10]) << 20);
665 v
|= ((uint64_t) hex_convert (hex
[ 9]) << 24);
666 v
|= ((uint64_t) hex_convert (hex
[ 8]) << 28);
667 v
|= ((uint64_t) hex_convert (hex
[ 7]) << 32);
668 v
|= ((uint64_t) hex_convert (hex
[ 6]) << 36);
669 v
|= ((uint64_t) hex_convert (hex
[ 5]) << 40);
670 v
|= ((uint64_t) hex_convert (hex
[ 4]) << 44);
671 v
|= ((uint64_t) hex_convert (hex
[ 3]) << 48);
672 v
|= ((uint64_t) hex_convert (hex
[ 2]) << 52);
673 v
|= ((uint64_t) hex_convert (hex
[ 1]) << 56);
674 v
|= ((uint64_t) hex_convert (hex
[ 0]) << 60);
679 void bin_to_hex_lower (uint v
, char hex
[8])
681 hex
[0] = v
>> 28 & 15;
682 hex
[1] = v
>> 24 & 15;
683 hex
[2] = v
>> 20 & 15;
684 hex
[3] = v
>> 16 & 15;
685 hex
[4] = v
>> 12 & 15;
686 hex
[5] = v
>> 8 & 15;
687 hex
[6] = v
>> 4 & 15;
688 hex
[7] = v
>> 0 & 15;
692 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
693 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
694 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
695 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
696 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
697 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
698 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
699 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
702 void phpass_decode (unsigned char digest
[16], unsigned char buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (unsigned char digest
[16], unsigned char buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (unsigned char digest
[16], unsigned char buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (unsigned char digest
[16], unsigned char buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (unsigned char digest
[64], unsigned char buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (unsigned char digest
[64], unsigned char buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (unsigned char digest
[20], unsigned char buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (unsigned char digest
[20], unsigned char buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (unsigned char digest
[32], unsigned char buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (unsigned char digest
[32], unsigned char buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (unsigned char digest
[64], unsigned char buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (unsigned char digest
[64], unsigned char buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (unsigned char digest
[32], unsigned char buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (unsigned char digest
[32], unsigned char buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (unsigned char digest
[64], unsigned char buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (unsigned char digest
[64], unsigned char buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2455 FlushConsoleInputBuffer (stdinHandle
);
2457 for (uint i
= 0; i
< num
; i
++)
2459 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2461 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2463 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2465 return KeyEvent
.uChar
.AsciiChar
;
2473 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2475 SetConsoleMode (stdinHandle
, saveMode
);
2485 #define MSG_ENOMEM "Insufficient memory available"
2487 void *mycalloc (size_t nmemb
, size_t size
)
2489 void *p
= calloc (nmemb
, size
);
2493 log_error ("ERROR: %s", MSG_ENOMEM
);
2501 void *mymalloc (size_t size
)
2503 void *p
= malloc (size
);
2507 log_error ("ERROR: %s", MSG_ENOMEM
);
2512 memset (p
, 0, size
);
2517 void myfree (void *ptr
)
2519 if (ptr
== NULL
) return;
2524 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2526 void *p
= realloc (ptr
, oldsz
+ add
);
2530 log_error ("ERROR: %s", MSG_ENOMEM
);
2535 memset ((char *) p
+ oldsz
, 0, add
);
2540 char *mystrdup (const char *s
)
2542 const size_t len
= strlen (s
);
2544 char *b
= (char *) mymalloc (len
+ 1);
2551 FILE *logfile_open (char *logfile
)
2553 FILE *fp
= fopen (logfile
, "ab");
2563 void logfile_close (FILE *fp
)
2565 if (fp
== stdout
) return;
2570 void logfile_append (const char *fmt
, ...)
2572 if (data
.logfile_disable
== 1) return;
2574 FILE *fp
= logfile_open (data
.logfile
);
2580 vfprintf (fp
, fmt
, ap
);
2591 int logfile_generate_id ()
2593 const int n
= rand ();
2602 char *logfile_generate_topid ()
2604 const int id
= logfile_generate_id ();
2606 char *topid
= (char *) mymalloc (1 + 16 + 1);
2608 sprintf (topid
, "TOP%08x", id
);
2613 char *logfile_generate_subid ()
2615 const int id
= logfile_generate_id ();
2617 char *subid
= (char *) mymalloc (1 + 16 + 1);
2619 sprintf (subid
, "SUB%08x", id
);
2631 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2633 FlushFileBuffers (h
);
2643 int hm_get_adapter_index (HM_ADAPTER nvGPUHandle
[DEVICES_MAX
])
2647 if (hc_NvAPI_EnumPhysicalGPUs (nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2651 log_info ("WARN: No NvAPI adapters found");
2661 int hm_get_adapter_index (HM_ADAPTER nvGPUHandle
[DEVICES_MAX
])
2665 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2667 /* do not use wrapper function to omit warning message */
2668 if (nvmlDeviceGetHandleByIndex (i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2670 //can be used to determine if the device by index matches the cuda device by index
2671 //char name[100]; memset (name, 0, sizeof (name));
2672 //hc_NVML_nvmlDeviceGetName (nvGPUHandle[i], name, sizeof (name) - 1);
2679 log_info ("WARN: No NVML adapters found");
2691 void hm_close (HM_LIB hm_dll
)
2697 FreeLibrary (hm_dll
);
2705 HM_LIB hm_dll
= dlopen ("libatiadlxx.so", RTLD_LAZY
| RTLD_GLOBAL
);
2708 HM_LIB hm_dll
= LoadLibrary ("atiadlxx.dll");
2711 hm_dll
= LoadLibrary ("atiadlxy.dll");
2718 int get_adapters_num (HM_LIB hm_dll
, int *iNumberAdapters
)
2720 if (hc_ADL_Adapter_NumberOfAdapters_Get (hm_dll
, iNumberAdapters
) != ADL_OK
) return -1;
2722 if (iNumberAdapters
== 0)
2724 log_info ("WARN: No ADL adapters found.");
2732 int hm_show_performance_level (HM_LIB hm_dll
, int iAdapterIndex
)
2734 ADLODPerformanceLevels
*lpOdPerformanceLevels
= NULL
;
2735 ADLODParameters lpOdParameters
;
2737 lpOdParameters
.iSize
= sizeof (ADLODParameters
);
2738 size_t plevels_size
= 0;
2740 if (hc_ADL_Overdrive_ODParameters_Get (hm_dll
, iAdapterIndex
, &lpOdParameters
) != ADL_OK
) return -1;
2742 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2743 __func__
, iAdapterIndex
,
2744 lpOdParameters
.iNumberOfPerformanceLevels
,
2745 (lpOdParameters
.iActivityReportingSupported
) ? "activity reporting" : "",
2746 (lpOdParameters
.iDiscretePerformanceLevels
) ? "discrete performance levels" : "performance ranges");
2748 plevels_size
= sizeof (ADLODPerformanceLevels
) + sizeof (ADLODPerformanceLevel
) * (lpOdParameters
.iNumberOfPerformanceLevels
- 1);
2750 lpOdPerformanceLevels
= (ADLODPerformanceLevels
*) mymalloc (plevels_size
);
2752 lpOdPerformanceLevels
->iSize
= sizeof (ADLODPerformanceLevels
) + sizeof (ADLODPerformanceLevel
) * (lpOdParameters
.iNumberOfPerformanceLevels
- 1);
2754 if (hc_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll
, iAdapterIndex
, 0, lpOdPerformanceLevels
) != ADL_OK
) return -1;
2756 for (int j
= 0; j
< lpOdParameters
.iNumberOfPerformanceLevels
; j
++)
2757 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2758 __func__
, iAdapterIndex
, j
,
2759 lpOdPerformanceLevels
->aLevels
[j
].iEngineClock
/ 100, lpOdPerformanceLevels
->aLevels
[j
].iMemoryClock
/ 100, lpOdPerformanceLevels
->aLevels
[j
].iVddc
);
2761 myfree (lpOdPerformanceLevels
);
2766 LPAdapterInfo
hm_get_adapter_info (HM_LIB hm_dll
, int iNumberAdapters
)
2768 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2770 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2772 if (hc_ADL_Adapter_AdapterInfo_Get (hm_dll
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2774 return lpAdapterInfo
;
2778 * does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2781 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2785 for (uint i = 0; i < num_adl_adapters; i++)
2787 int opencl_bus_num = hm_device[i].busid;
2788 int opencl_dev_num = hm_device[i].devid;
2790 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2798 if (idx >= DEVICES_MAX) return -1;
2803 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2805 for (uint i = 0; i < opencl_num_devices; i++)
2807 cl_device_topology_amd device_topology;
2809 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2811 hm_device[i].busid = device_topology.pcie.bus;
2812 hm_device[i].devid = device_topology.pcie.device;
2817 void hm_sort_adl_adapters_by_busid_devid (uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2819 // basically bubble sort
2821 for (int i
= 0; i
< num_adl_adapters
; i
++)
2823 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2825 // get info of adapter [x]
2827 uint32_t adapter_index_x
= valid_adl_device_list
[j
];
2828 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2830 uint32_t bus_num_x
= info_x
.iBusNumber
;
2831 uint32_t dev_num_x
= info_x
.iDeviceNumber
;
2833 // get info of adapter [y]
2835 uint32_t adapter_index_y
= valid_adl_device_list
[j
+ 1];
2836 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2838 uint32_t bus_num_y
= info_y
.iBusNumber
;
2839 uint32_t dev_num_y
= info_y
.iDeviceNumber
;
2843 if (bus_num_y
< bus_num_x
)
2847 else if (bus_num_y
== bus_num_x
)
2849 if (dev_num_y
< dev_num_x
)
2857 uint32_t temp
= valid_adl_device_list
[j
+ 1];
2859 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2860 valid_adl_device_list
[j
+ 0] = temp
;
2866 uint32_t *hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2868 *num_adl_adapters
= 0;
2870 uint32_t *adl_adapters
= NULL
;
2872 int *bus_numbers
= NULL
;
2873 int *device_numbers
= NULL
;
2875 for (int i
= 0; i
< iNumberAdapters
; i
++)
2877 AdapterInfo info
= lpAdapterInfo
[i
];
2879 if ((info
.strUDID
== NULL
) || (strlen (info
.strUDID
) < 1)) continue;
2882 if (info
.iVendorID
!= 1002) continue;
2884 if (info
.iVendorID
!= 0x1002) continue;
2887 if (info
.iBusNumber
< 0) continue;
2888 if (info
.iDeviceNumber
< 0) continue;
2892 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2894 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2901 if (found
) continue;
2903 // add it to the list
2905 adl_adapters
= (uint32_t *) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2907 adl_adapters
[*num_adl_adapters
] = i
;
2909 // rest is just bookkeeping
2911 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2912 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2914 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2915 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2917 (*num_adl_adapters
)++;
2920 myfree (bus_numbers
);
2921 myfree (device_numbers
);
2923 // sort the list by increasing bus id, device id number
2925 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2927 return adl_adapters
;
2930 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
)
2932 // loop through all valid devices
2934 for (int i
= 0; i
< num_adl_adapters
; i
++)
2936 uint32_t adapter_index
= valid_adl_device_list
[i
];
2940 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2942 // unfortunately this doesn't work since bus id and dev id are not unique
2943 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2944 // if (opencl_device_index == -1) continue;
2946 int opencl_device_index
= i
;
2948 // if (hm_show_performance_level (hm_dll, info.iAdapterIndex) != 0) return -1;
2950 // get fanspeed info
2952 if (hm_device
[opencl_device_index
].od_version
== 5)
2954 ADLFanSpeedInfo FanSpeedInfo
;
2956 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2958 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2960 if (hc_ADL_Overdrive5_FanSpeedInfo_Get (hm_dll
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2962 // check read and write capability in fanspeedinfo
2964 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2965 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2967 hm_device
[opencl_device_index
].fan_supported
= 1;
2971 hm_device
[opencl_device_index
].fan_supported
= 0;
2974 else // od_version == 6
2976 ADLOD6FanSpeedInfo faninfo
;
2978 memset (&faninfo
, 0, sizeof (faninfo
));
2980 if (hc_ADL_Overdrive6_FanSpeed_Get (hm_dll
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2982 // check read capability in fanspeedinfo
2984 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2986 hm_device
[opencl_device_index
].fan_supported
= 1;
2990 hm_device
[opencl_device_index
].fan_supported
= 0;
2998 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
)
3000 for (int i
= 0; i
< num_adl_adapters
; i
++)
3002 uint32_t adapter_index
= valid_adl_device_list
[i
];
3006 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3008 // get overdrive version
3010 int od_supported
= 0;
3014 if (hc_ADL_Overdrive_Caps (hm_dll
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3016 // store the overdrive version in hm_device
3018 // unfortunately this doesn't work since bus id and dev id are not unique
3019 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3020 // if (opencl_device_index == -1) continue;
3022 int opencl_device_index
= i
;
3024 hm_device
[opencl_device_index
].od_version
= od_version
;
3030 int hm_get_adapter_index (hm_attrs_t
*hm_device
, uint32_t *valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3032 for (int i
= 0; i
< num_adl_adapters
; i
++)
3034 uint32_t adapter_index
= valid_adl_device_list
[i
];
3038 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3040 // store the iAdapterIndex in hm_device
3042 // unfortunately this doesn't work since bus id and dev id are not unique
3043 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3044 // if (opencl_device_index == -1) continue;
3046 int opencl_device_index
= i
;
3048 hm_device
[opencl_device_index
].adapter_index
= info
.iAdapterIndex
;
3051 return num_adl_adapters
;
3056 int hm_get_temperature_with_device_id (const uint device_id
)
3062 if (data
.hm_device
[device_id
].od_version
== 5)
3064 ADLTemperature Temperature
;
3066 Temperature
.iSize
= sizeof (ADLTemperature
);
3068 if (hc_ADL_Overdrive5_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
, 0, &Temperature
) != ADL_OK
) return -1;
3070 return Temperature
.iTemperature
/ 1000;
3072 else if (data
.hm_device
[device_id
].od_version
== 6)
3074 int Temperature
= 0;
3076 if (hc_ADL_Overdrive6_Temperature_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
, &Temperature
) != ADL_OK
) return -1;
3078 return Temperature
/ 1000;
3086 int temperature
= 0;
3088 hc_NVML_nvmlDeviceGetTemperature (data
.hm_device
[device_id
].adapter_index
, NVML_TEMPERATURE_GPU
, (unsigned int *) &temperature
);
3094 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3096 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3097 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3098 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3099 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3101 if (hc_NvAPI_GPU_GetThermalSettings (data
.hm_device
[device_id
].adapter_index
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3103 return pThermalSettings
.sensor
[0].currentTemp
;
3110 int hm_get_fanspeed_with_device_id (const uint device_id
)
3112 if (data
.hm_device
[device_id
].fan_supported
== 1)
3118 if (data
.hm_device
[device_id
].od_version
== 5)
3120 ADLFanSpeedValue lpFanSpeedValue
;
3122 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3124 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3125 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3126 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3128 if (hc_ADL_Overdrive5_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3130 return lpFanSpeedValue
.iFanSpeed
;
3132 else // od_version == 6
3134 ADLOD6FanSpeedInfo faninfo
;
3136 memset (&faninfo
, 0, sizeof (faninfo
));
3138 if (hc_ADL_Overdrive6_FanSpeed_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
, &faninfo
) != ADL_OK
) return -1;
3140 return faninfo
.iFanSpeedPercent
;
3150 hc_NVML_nvmlDeviceGetFanSpeed (data
.hm_device
[device_id
].adapter_index
, (unsigned int *) &speed
);
3158 hc_NvAPI_GPU_GetTachReading (data
.hm_device
[device_id
].adapter_index
, &speed
);
3168 int hm_get_utilization_with_device_id (const uint device_id
)
3174 ADLPMActivity PMActivity
;
3176 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3178 if (hc_ADL_Overdrive_CurrentActivity_Get (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
, &PMActivity
) != ADL_OK
) return -1;
3180 return PMActivity
.iActivityPercent
;
3187 nvmlUtilization_t utilization
;
3189 hc_NVML_nvmlDeviceGetUtilizationRates (data
.hm_device
[device_id
].adapter_index
, &utilization
);
3191 return utilization
.gpu
;
3195 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3197 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3199 if (hc_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_device
[device_id
].adapter_index
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3201 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3210 int hm_set_fanspeed_with_device_id (const uint device_id
, const int fanspeed
)
3212 if (data
.hm_device
[device_id
].fan_supported
== 1)
3216 if (data
.hm_device
[device_id
].od_version
== 5)
3218 ADLFanSpeedValue lpFanSpeedValue
;
3220 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3222 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3223 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3224 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3225 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3227 if (hc_ADL_Overdrive5_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3231 else // od_version == 6
3233 ADLOD6FanSpeedValue fan_speed_value
;
3235 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3237 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3238 fan_speed_value
.iFanSpeed
= fanspeed
;
3240 if (hc_ADL_Overdrive6_FanSpeed_Set (data
.hm_dll
, data
.hm_device
[device_id
].adapter_index
, &fan_speed_value
) != ADL_OK
) return -1;
3256 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3258 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3260 if (css_cnt
> SP_PW_MAX
)
3262 log_error ("ERROR: mask length is too long");
3267 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3269 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3271 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3272 uint cs_len
= css
[css_pos
].cs_len
;
3274 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3276 uint c
= cs_buf
[cs_pos
] & 0xff;
3283 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3285 cs_t
*cs
= &css
[css_cnt
];
3287 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3289 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3291 memset (css_uniq
, 0, css_uniq_sz
);
3295 for (i
= 0; i
< cs
->cs_len
; i
++)
3297 const uint u
= cs
->cs_buf
[i
];
3302 for (i
= 0; i
< in_len
; i
++)
3304 uint u
= in_buf
[i
] & 0xff;
3306 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3308 if (css_uniq
[u
] == 1) continue;
3312 cs
->cs_buf
[cs
->cs_len
] = u
;
3320 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3324 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3326 uint p0
= in_buf
[in_pos
] & 0xff;
3328 if (interpret
== 1 && p0
== '?')
3332 if (in_pos
== in_len
) break;
3334 uint p1
= in_buf
[in_pos
] & 0xff;
3338 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3340 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3342 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3344 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3346 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3348 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3350 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3351 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3353 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3354 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3356 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3357 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3359 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3360 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3362 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3364 default: log_error ("Syntax error: %s", in_buf
);
3370 if (data
.hex_charset
)
3374 if (in_pos
== in_len
)
3376 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3381 uint p1
= in_buf
[in_pos
] & 0xff;
3383 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3385 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3392 chr
= hex_convert (p1
) << 0;
3393 chr
|= hex_convert (p0
) << 4;
3395 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3401 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3407 uint64_t mp_get_sum (uint css_cnt
, cs_t
*css
)
3411 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3413 sum
*= css
[css_pos
].cs_len
;
3419 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3421 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3426 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3428 char p0
= mask_buf
[mask_pos
];
3434 if (mask_pos
== mask_len
) break;
3436 char p1
= mask_buf
[mask_pos
];
3442 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3444 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3446 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3448 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3450 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3452 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3454 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3455 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3457 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3458 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3460 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3461 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3463 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3464 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3466 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3468 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3474 if (data
.hex_charset
)
3478 // if there is no 2nd hex character, show an error:
3480 if (mask_pos
== mask_len
)
3482 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3487 char p1
= mask_buf
[mask_pos
];
3489 // if they are not valid hex character, show an error:
3491 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3493 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3500 chr
|= hex_convert (p1
) << 0;
3501 chr
|= hex_convert (p0
) << 4;
3503 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3509 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3516 log_error ("ERROR: invalid mask length (0)");
3526 void mp_exec (uint64_t val
, char *buf
, cs_t
*css
, int css_cnt
)
3528 for (int i
= 0; i
< css_cnt
; i
++)
3530 uint len
= css
[i
].cs_len
;
3531 uint64_t next
= val
/ len
;
3532 uint pos
= val
% len
;
3533 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3538 void mp_cut_at (char *mask
, uint max
)
3542 uint mask_len
= strlen (mask
);
3544 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3546 if (mask
[i
] == '?') i
++;
3552 void mp_setup_sys (cs_t
*mp_sys
)
3556 uint donec
[CHARSIZ
];
3558 memset (donec
, 0, sizeof (donec
));
3560 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3561 mp_sys
[0].cs_buf
[pos
++] = chr
;
3562 mp_sys
[0].cs_len
= pos
; }
3564 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3565 mp_sys
[1].cs_buf
[pos
++] = chr
;
3566 mp_sys
[1].cs_len
= pos
; }
3568 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3569 mp_sys
[2].cs_buf
[pos
++] = chr
;
3570 mp_sys
[2].cs_len
= pos
; }
3572 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3573 mp_sys
[3].cs_buf
[pos
++] = chr
;
3574 mp_sys
[3].cs_len
= pos
; }
3576 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3577 mp_sys
[4].cs_len
= pos
; }
3579 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3580 mp_sys
[5].cs_len
= pos
; }
3583 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3585 FILE *fp
= fopen (buf
, "rb");
3587 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3589 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3595 memset (mp_file
, 0, sizeof (mp_file
));
3597 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3601 len
= in_superchop (mp_file
);
3605 log_info ("WARNING: charset file corrupted");
3607 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3611 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3616 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3618 mp_usr
[index
].cs_len
= 0;
3620 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3623 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3625 char *new_mask_buf
= (char *) mymalloc (256);
3631 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3633 if (css_pos
== len
) break;
3635 char p0
= mask_buf
[mask_pos
];
3637 new_mask_buf
[mask_pos
] = p0
;
3643 if (mask_pos
== mask_len
) break;
3645 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3649 if (data
.hex_charset
)
3653 if (mask_pos
== mask_len
)
3655 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3660 char p1
= mask_buf
[mask_pos
];
3662 // if they are not valid hex character, show an error:
3664 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3666 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3671 new_mask_buf
[mask_pos
] = p1
;
3676 if (css_pos
== len
) return (new_mask_buf
);
3678 myfree (new_mask_buf
);
3687 uint64_t sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3693 for (i
= start
; i
< stop
; i
++)
3695 sum
*= root_css_buf
[i
].cs_len
;
3701 void sp_exec (uint64_t ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3705 cs_t
*cs
= &root_css_buf
[start
];
3709 for (i
= start
; i
< stop
; i
++)
3711 const uint64_t m
= v
% cs
->cs_len
;
3712 const uint64_t d
= v
/ cs
->cs_len
;
3716 const uint k
= cs
->cs_buf
[m
];
3718 pw_buf
[i
- start
] = (char) k
;
3720 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3724 int sp_comp_val (const void *p1
, const void *p2
)
3726 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3727 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3729 return b2
->val
- b1
->val
;
3732 void sp_setup_tbl (const char *install_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3739 * Initialize hcstats
3742 uint64_t *root_stats_buf
= (uint64_t *) mycalloc (SP_ROOT_CNT
, sizeof (uint64_t));
3744 uint64_t *root_stats_ptr
= root_stats_buf
;
3746 uint64_t *root_stats_buf_by_pos
[SP_PW_MAX
];
3748 for (i
= 0; i
< SP_PW_MAX
; i
++)
3750 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3752 root_stats_ptr
+= CHARSIZ
;
3755 uint64_t *markov_stats_buf
= (uint64_t *) mycalloc (SP_MARKOV_CNT
, sizeof (uint64_t));
3757 uint64_t *markov_stats_ptr
= markov_stats_buf
;
3759 uint64_t *markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3761 for (i
= 0; i
< SP_PW_MAX
; i
++)
3763 for (j
= 0; j
< CHARSIZ
; j
++)
3765 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3767 markov_stats_ptr
+= CHARSIZ
;
3777 char hcstat_tmp
[256];
3779 memset (hcstat_tmp
, 0, sizeof (hcstat_tmp
));
3781 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", install_dir
, SP_HCSTAT
);
3783 hcstat
= hcstat_tmp
;
3786 FILE *fd
= fopen (hcstat
, "rb");
3790 log_error ("%s: %s", hcstat
, strerror (errno
));
3795 if (fread (root_stats_buf
, sizeof (uint64_t), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3797 log_error ("%s: Could not load data", hcstat
);
3802 if (fread (markov_stats_buf
, sizeof (uint64_t), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3804 log_error ("%s: Could not load data", hcstat
);
3812 * Markov modifier of hcstat_table on user request
3817 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (uint64_t));
3818 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (uint64_t));
3823 /* Add all stats to first position */
3825 for (i
= 1; i
< SP_PW_MAX
; i
++)
3827 uint64_t *out
= root_stats_buf_by_pos
[0];
3828 uint64_t *in
= root_stats_buf_by_pos
[i
];
3830 for (j
= 0; j
< CHARSIZ
; j
++)
3836 for (i
= 1; i
< SP_PW_MAX
; i
++)
3838 uint64_t *out
= markov_stats_buf_by_key
[0][0];
3839 uint64_t *in
= markov_stats_buf_by_key
[i
][0];
3841 for (j
= 0; j
< CHARSIZ
; j
++)
3843 for (k
= 0; k
< CHARSIZ
; k
++)
3850 /* copy them to all pw_positions */
3852 for (i
= 1; i
< SP_PW_MAX
; i
++)
3854 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (uint64_t));
3857 for (i
= 1; i
< SP_PW_MAX
; i
++)
3859 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (uint64_t));
3867 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3869 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3871 for (i
= 0; i
< SP_PW_MAX
; i
++)
3873 root_table_buf_by_pos
[i
] = root_table_ptr
;
3875 root_table_ptr
+= CHARSIZ
;
3878 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3880 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3882 for (i
= 0; i
< SP_PW_MAX
; i
++)
3884 for (j
= 0; j
< CHARSIZ
; j
++)
3886 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3888 markov_table_ptr
+= CHARSIZ
;
3893 * Convert hcstat to tables
3896 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3898 uint key
= i
% CHARSIZ
;
3900 root_table_buf
[i
].key
= key
;
3901 root_table_buf
[i
].val
= root_stats_buf
[i
];
3904 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3906 uint key
= i
% CHARSIZ
;
3908 markov_table_buf
[i
].key
= key
;
3909 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3912 myfree (root_stats_buf
);
3913 myfree (markov_stats_buf
);
3919 for (i
= 0; i
< SP_PW_MAX
; i
++)
3921 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3924 for (i
= 0; i
< SP_PW_MAX
; i
++)
3926 for (j
= 0; j
< CHARSIZ
; j
++)
3928 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3933 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
])
3936 * Convert tables to css
3939 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3941 uint pw_pos
= i
/ CHARSIZ
;
3943 cs_t
*cs
= &root_css_buf
[pw_pos
];
3945 if (cs
->cs_len
== threshold
) continue;
3947 uint key
= root_table_buf
[i
].key
;
3949 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3951 cs
->cs_buf
[cs
->cs_len
] = key
;
3957 * Convert table to css
3960 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3962 uint c
= i
/ CHARSIZ
;
3964 cs_t
*cs
= &markov_css_buf
[c
];
3966 if (cs
->cs_len
== threshold
) continue;
3968 uint pw_pos
= c
/ CHARSIZ
;
3970 uint key
= markov_table_buf
[i
].key
;
3972 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
3974 cs
->cs_buf
[cs
->cs_len
] = key
;
3980 for (uint i = 0; i < 8; i++)
3982 for (uint j = 0x20; j < 0x80; j++)
3984 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
3986 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
3988 for (uint k = 0; k < 10; k++)
3990 printf (" %u\n", ptr->cs_buf[k]);
3997 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
3999 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4001 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4011 for (uint j
= 1; j
< CHARSIZ
; j
++)
4021 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4023 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4025 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4027 out
+= CHARSIZ
* CHARSIZ
;
4028 in
+= CHARSIZ
* CHARSIZ
;
4030 for (uint j
= 0; j
< CHARSIZ
; j
++)
4037 for (uint k
= 1; k
< CHARSIZ
; k
++)
4049 * mixed shared functions
4052 void dump_hex (const char *s
, size_t size
)
4056 for (i
= 0; i
< size
; i
++)
4058 log_info_nn ("%02x ", (unsigned char) s
[i
]);
4064 void usage_mini_print (const char *progname
)
4066 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4069 void usage_big_print (const char *progname
)
4071 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4074 char *get_install_dir (const char *progname
)
4076 char *install_dir
= mystrdup (progname
);
4077 char *last_slash
= NULL
;
4079 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4083 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4089 install_dir
[0] = '.';
4093 return (install_dir
);
4096 void truecrypt_crc32 (char *file
, unsigned char keytab
[64])
4100 FILE *fd
= fopen (file
, "rb");
4104 log_error ("%s: %s", file
, strerror (errno
));
4109 #define MAX_KEY_SIZE (1024 * 1024)
4111 char *buf
= (char *) mymalloc (MAX_KEY_SIZE
);
4113 int nread
= fread (buf
, 1, MAX_KEY_SIZE
, fd
);
4117 for (int fpos
= 0; fpos
< nread
; fpos
++)
4119 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4121 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4122 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4123 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4124 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4126 if (kpos
>= 64) kpos
= 0;
4134 void set_cpu_affinity (char *cpu_affinity
)
4137 DWORD_PTR aff_mask
= 0;
4148 char *devices
= strdup (cpu_affinity
);
4150 char *next
= strtok (devices
, ",");
4154 uint cpu_id
= atoi (next
);
4171 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4177 aff_mask
|= 1 << (cpu_id
- 1);
4181 CPU_SET ((cpu_id
- 1), &cpuset
);
4184 } while ((next
= strtok (NULL
, ",")) != NULL
);
4190 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4191 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4195 pthread_t thread
= pthread_self ();
4196 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4200 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4202 char *element
, *end
;
4204 end
= (char *) base
+ nmemb
* size
;
4206 for (element
= (char *) base
; element
< end
; element
+= size
)
4207 if (!compar (element
, key
))
4213 int sort_by_salt (const void *v1
, const void *v2
)
4215 const salt_t
*s1
= (const salt_t
*) v1
;
4216 const salt_t
*s2
= (const salt_t
*) v2
;
4218 const int res1
= s1
->salt_len
- s2
->salt_len
;
4220 if (res1
!= 0) return (res1
);
4222 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4224 if (res2
!= 0) return (res2
);
4232 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4233 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4240 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4241 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4247 int sort_by_salt_buf (const void *v1
, const void *v2
)
4249 const pot_t
*p1
= (const pot_t
*) v1
;
4250 const pot_t
*p2
= (const pot_t
*) v2
;
4252 const hash_t
*h1
= &p1
->hash
;
4253 const hash_t
*h2
= &p2
->hash
;
4255 const salt_t
*s1
= h1
->salt
;
4256 const salt_t
*s2
= h2
->salt
;
4262 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4263 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4269 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4271 const hash_t
*h1
= (const hash_t
*) v1
;
4272 const hash_t
*h2
= (const hash_t
*) v2
;
4274 const salt_t
*s1
= h1
->salt
;
4275 const salt_t
*s2
= h2
->salt
;
4277 // testphase: this should work
4282 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4283 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4286 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4287 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4288 if (s1->salt_len > s2->salt_len) return ( 1);
4289 if (s1->salt_len < s2->salt_len) return (-1);
4291 uint n = s1->salt_len;
4295 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4296 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4303 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4305 const hash_t
*h1
= (const hash_t
*) v1
;
4306 const hash_t
*h2
= (const hash_t
*) v2
;
4308 const salt_t
*s1
= h1
->salt
;
4309 const salt_t
*s2
= h2
->salt
;
4311 // 12 - 2 (since last 2 uints contain the digest)
4316 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4317 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4323 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4325 const hash_t
*h1
= (const hash_t
*) v1
;
4326 const hash_t
*h2
= (const hash_t
*) v2
;
4328 const void *d1
= h1
->digest
;
4329 const void *d2
= h2
->digest
;
4331 return data
.sort_by_digest (d1
, d2
);
4334 int sort_by_hash (const void *v1
, const void *v2
)
4336 const hash_t
*h1
= (const hash_t
*) v1
;
4337 const hash_t
*h2
= (const hash_t
*) v2
;
4341 const salt_t
*s1
= h1
->salt
;
4342 const salt_t
*s2
= h2
->salt
;
4344 int res
= sort_by_salt (s1
, s2
);
4346 if (res
!= 0) return (res
);
4349 const void *d1
= h1
->digest
;
4350 const void *d2
= h2
->digest
;
4352 return data
.sort_by_digest (d1
, d2
);
4355 int sort_by_pot (const void *v1
, const void *v2
)
4357 const pot_t
*p1
= (const pot_t
*) v1
;
4358 const pot_t
*p2
= (const pot_t
*) v2
;
4360 const hash_t
*h1
= &p1
->hash
;
4361 const hash_t
*h2
= &p2
->hash
;
4363 return sort_by_hash (h1
, h2
);
4366 int sort_by_mtime (const void *p1
, const void *p2
)
4368 const char **f1
= (const char **) p1
;
4369 const char **f2
= (const char **) p2
;
4371 struct stat s1
; stat (*f1
, &s1
);
4372 struct stat s2
; stat (*f2
, &s2
);
4374 return s2
.st_mtime
- s1
.st_mtime
;
4377 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4379 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4380 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4382 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4385 int sort_by_gpu_rule (const void *p1
, const void *p2
)
4387 const gpu_rule_t
*r1
= (const gpu_rule_t
*) p1
;
4388 const gpu_rule_t
*r2
= (const gpu_rule_t
*) p2
;
4390 return memcmp (r1
, r2
, sizeof (gpu_rule_t
));
4393 int sort_by_stringptr (const void *p1
, const void *p2
)
4395 const char **s1
= (const char **) p1
;
4396 const char **s2
= (const char **) p2
;
4398 return strcmp (*s1
, *s2
);
4401 int sort_by_dictstat (const void *s1
, const void *s2
)
4403 dictstat_t
*d1
= (dictstat_t
*) s1
;
4404 dictstat_t
*d2
= (dictstat_t
*) s2
;
4407 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4409 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4412 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4415 int sort_by_bitmap (const void *p1
, const void *p2
)
4417 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4418 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4420 return b1
->collisions
- b2
->collisions
;
4423 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4425 const uint32_t *d1
= (const uint32_t *) v1
;
4426 const uint32_t *d2
= (const uint32_t *) v2
;
4432 if (d1
[n
] > d2
[n
]) return ( 1);
4433 if (d1
[n
] < d2
[n
]) return (-1);
4439 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4441 const uint32_t *d1
= (const uint32_t *) v1
;
4442 const uint32_t *d2
= (const uint32_t *) v2
;
4448 if (d1
[n
] > d2
[n
]) return ( 1);
4449 if (d1
[n
] < d2
[n
]) return (-1);
4455 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4457 const uint32_t *d1
= (const uint32_t *) v1
;
4458 const uint32_t *d2
= (const uint32_t *) v2
;
4464 if (d1
[n
] > d2
[n
]) return ( 1);
4465 if (d1
[n
] < d2
[n
]) return (-1);
4471 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4473 const uint32_t *d1
= (const uint32_t *) v1
;
4474 const uint32_t *d2
= (const uint32_t *) v2
;
4480 if (d1
[n
] > d2
[n
]) return ( 1);
4481 if (d1
[n
] < d2
[n
]) return (-1);
4487 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4489 const uint32_t *d1
= (const uint32_t *) v1
;
4490 const uint32_t *d2
= (const uint32_t *) v2
;
4496 if (d1
[n
] > d2
[n
]) return ( 1);
4497 if (d1
[n
] < d2
[n
]) return (-1);
4503 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4505 const uint32_t *d1
= (const uint32_t *) v1
;
4506 const uint32_t *d2
= (const uint32_t *) v2
;
4512 if (d1
[n
] > d2
[n
]) return ( 1);
4513 if (d1
[n
] < d2
[n
]) return (-1);
4519 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4521 const uint32_t *d1
= (const uint32_t *) v1
;
4522 const uint32_t *d2
= (const uint32_t *) v2
;
4528 if (d1
[n
] > d2
[n
]) return ( 1);
4529 if (d1
[n
] < d2
[n
]) return (-1);
4535 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4537 const uint32_t *d1
= (const uint32_t *) v1
;
4538 const uint32_t *d2
= (const uint32_t *) v2
;
4544 if (d1
[n
] > d2
[n
]) return ( 1);
4545 if (d1
[n
] < d2
[n
]) return (-1);
4551 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4553 const uint64_t *d1
= (const uint64_t *) v1
;
4554 const uint64_t *d2
= (const uint64_t *) v2
;
4560 if (d1
[n
] > d2
[n
]) return ( 1);
4561 if (d1
[n
] < d2
[n
]) return (-1);
4567 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4569 const uint64_t *d1
= (const uint64_t *) v1
;
4570 const uint64_t *d2
= (const uint64_t *) v2
;
4576 if (d1
[n
] > d2
[n
]) return ( 1);
4577 if (d1
[n
] < d2
[n
]) return (-1);
4583 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4585 const uint64_t *d1
= (const uint64_t *) v1
;
4586 const uint64_t *d2
= (const uint64_t *) v2
;
4592 if (d1
[n
] > d2
[n
]) return ( 1);
4593 if (d1
[n
] < d2
[n
]) return (-1);
4599 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4601 const uint32_t *d1
= (const uint32_t *) v1
;
4602 const uint32_t *d2
= (const uint32_t *) v2
;
4604 const uint dgst_pos0
= data
.dgst_pos0
;
4605 const uint dgst_pos1
= data
.dgst_pos1
;
4606 const uint dgst_pos2
= data
.dgst_pos2
;
4607 const uint dgst_pos3
= data
.dgst_pos3
;
4609 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4610 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4611 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4612 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4613 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4614 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4615 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4616 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4621 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
)
4623 uint outfile_autohex
= data
.outfile_autohex
;
4625 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4627 FILE *debug_fp
= NULL
;
4629 if (debug_file
!= NULL
)
4631 debug_fp
= fopen (debug_file
, "ab");
4638 if (debug_fp
== NULL
)
4640 log_info ("WARNING: Could not open debug-file for writing");
4644 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4646 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4648 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4651 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4653 if (debug_mode
== 4)
4655 fputc (':', debug_fp
);
4657 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4660 fputc ('\n', debug_fp
);
4662 if (debug_file
!= NULL
) fclose (debug_fp
);
4666 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4668 int needs_hexify
= 0;
4670 if (outfile_autohex
== 1)
4672 for (uint i
= 0; i
< plain_len
; i
++)
4674 if (plain_ptr
[i
] < 0x20)
4681 if (plain_ptr
[i
] > 0x7f)
4690 if (needs_hexify
== 1)
4692 fprintf (fp
, "$HEX[");
4694 for (uint i
= 0; i
< plain_len
; i
++)
4696 fprintf (fp
, "%02x", plain_ptr
[i
]);
4703 fwrite (plain_ptr
, plain_len
, 1, fp
);
4707 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
)
4709 uint outfile_format
= data
.outfile_format
;
4711 char separator
= data
.separator
;
4713 if (outfile_format
& OUTFILE_FMT_HASH
)
4715 fprintf (out_fp
, "%s", out_buf
);
4717 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4719 fputc (separator
, out_fp
);
4722 else if (data
.username
)
4724 if (username
!= NULL
)
4726 for (uint i
= 0; i
< user_len
; i
++)
4728 fprintf (out_fp
, "%c", username
[i
]);
4731 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4733 fputc (separator
, out_fp
);
4738 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4740 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4742 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4744 fputc (separator
, out_fp
);
4748 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4750 for (uint i
= 0; i
< plain_len
; i
++)
4752 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4755 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4757 fputc (separator
, out_fp
);
4761 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4764 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4769 fprintf (out_fp
, "%lu", crackpos
);
4771 fprintf (out_fp
, "%llu", crackpos
);
4776 fputc ('\n', out_fp
);
4779 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
)
4783 pot_key
.hash
.salt
= hashes_buf
->salt
;
4784 pot_key
.hash
.digest
= hashes_buf
->digest
;
4786 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4792 input_buf
[input_len
] = 0;
4795 unsigned char *username
= NULL
;
4800 user_t
*user
= hashes_buf
->hash_info
->user
;
4804 username
= (unsigned char *) (user
->user_name
);
4806 user_len
= user
->user_len
;
4810 // do output the line
4811 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4815 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4816 #define LM_MASKED_PLAIN "[notfound]"
4818 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
)
4824 pot_left_key
.hash
.salt
= hash_left
->salt
;
4825 pot_left_key
.hash
.digest
= hash_left
->digest
;
4827 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4831 uint weak_hash_found
= 0;
4833 pot_t pot_right_key
;
4835 pot_right_key
.hash
.salt
= hash_right
->salt
;
4836 pot_right_key
.hash
.digest
= hash_right
->digest
;
4838 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4840 if (pot_right_ptr
== NULL
)
4842 // special case, if "weak hash"
4844 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4846 weak_hash_found
= 1;
4848 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4850 // in theory this is not needed, but we are paranoia:
4852 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4853 pot_right_ptr
->plain_len
= 0;
4857 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
4859 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
4864 // at least one half was found:
4868 input_buf
[input_len
] = 0;
4872 unsigned char *username
= NULL
;
4877 user_t
*user
= hash_left
->hash_info
->user
;
4881 username
= (unsigned char *) (user
->user_name
);
4883 user_len
= user
->user_len
;
4887 // mask the part which was not found
4889 uint left_part_masked
= 0;
4890 uint right_part_masked
= 0;
4892 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
4894 if (pot_left_ptr
== NULL
)
4896 left_part_masked
= 1;
4898 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4900 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
4902 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4903 pot_left_ptr
->plain_len
= mask_plain_len
;
4906 if (pot_right_ptr
== NULL
)
4908 right_part_masked
= 1;
4910 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4912 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
4914 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
4915 pot_right_ptr
->plain_len
= mask_plain_len
;
4918 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
4922 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
4924 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
4926 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
4928 // do output the line
4930 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
4932 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4934 if (left_part_masked
== 1) myfree (pot_left_ptr
);
4935 if (right_part_masked
== 1) myfree (pot_right_ptr
);
4938 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
)
4942 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
4944 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4946 if (pot_ptr
== NULL
)
4950 input_buf
[input_len
] = 0;
4952 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
4956 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
)
4962 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
4964 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4968 pot_t pot_right_key
;
4970 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
4972 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4974 uint weak_hash_found
= 0;
4976 if (pot_right_ptr
== NULL
)
4978 // special case, if "weak hash"
4980 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
4982 weak_hash_found
= 1;
4984 // we just need that pot_right_ptr is not a NULL pointer
4986 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
4990 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
4992 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
4997 // ... at least one part was not cracked
5001 input_buf
[input_len
] = 0;
5003 // only show the hash part which is still not cracked
5005 uint user_len
= input_len
- 32;
5007 char hash_output
[user_len
+ 33];
5009 memset (hash_output
, 0, sizeof (hash_output
));
5011 memcpy (hash_output
, input_buf
, input_len
);
5013 if (pot_left_ptr
!= NULL
)
5015 // only show right part (because left part was already found)
5017 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5019 hash_output
[user_len
+ 16] = 0;
5022 if (pot_right_ptr
!= NULL
)
5024 // only show left part (because right part was already found)
5026 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5028 hash_output
[user_len
+ 16] = 0;
5031 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5033 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5036 uint
devices_to_devicemask (char *gpu_devices
)
5038 uint gpu_devicemask
= 0;
5042 char *devices
= strdup (gpu_devices
);
5044 char *next
= strtok (devices
, ",");
5048 uint gpu_id
= atoi (next
);
5050 if (gpu_id
< 1 || gpu_id
> 8)
5052 log_error ("ERROR: invalid gpu_id %u specified", gpu_id
);
5057 gpu_devicemask
|= 1 << (gpu_id
- 1);
5059 } while ((next
= strtok (NULL
, ",")) != NULL
);
5064 return gpu_devicemask
;
5067 uint
get_random_num (uint min
, uint max
)
5069 if (min
== max
) return (min
);
5071 return (uint
) ((rand () % (max
- min
)) + min
);
5074 uint32_t mydivc32 (const uint32_t dividend
, const uint32_t divisor
)
5076 uint32_t quotient
= dividend
/ divisor
;
5078 if (dividend
% divisor
) quotient
++;
5083 uint64_t mydivc64 (const uint64_t dividend
, const uint64_t divisor
)
5085 uint64_t quotient
= dividend
/ divisor
;
5087 if (dividend
% divisor
) quotient
++;
5092 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5094 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5095 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5097 if (tm
->tm_year
- 70)
5099 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5100 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5102 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5104 else if (tm
->tm_yday
)
5106 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5107 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5109 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5111 else if (tm
->tm_hour
)
5113 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5114 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5116 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5118 else if (tm
->tm_min
)
5120 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5121 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5123 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5127 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5129 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5133 void format_speed_display (float val
, char *buf
, size_t len
)
5144 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5155 /* generate output */
5159 snprintf (buf
, len
- 1, "%.0f ", val
);
5163 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5167 void lowercase (char *buf
, int len
)
5169 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5172 void uppercase (char *buf
, int len
)
5174 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5177 int fgetl (FILE *fp
, char *line_buf
)
5183 const int c
= fgetc (fp
);
5185 if (c
== EOF
) break;
5187 line_buf
[line_len
] = (char) c
;
5191 if (line_len
== BUFSIZ
) line_len
--;
5193 if (c
== '\n') break;
5196 if (line_len
== 0) return 0;
5198 if (line_buf
[line_len
- 1] == '\n')
5202 line_buf
[line_len
] = 0;
5205 if (line_len
== 0) return 0;
5207 if (line_buf
[line_len
- 1] == '\r')
5211 line_buf
[line_len
] = 0;
5217 int in_superchop (char *buf
)
5219 int len
= strlen (buf
);
5223 if (buf
[len
- 1] == '\n')
5230 if (buf
[len
- 1] == '\r')
5245 char **scan_directory (const char *path
)
5247 char *tmp_path
= mystrdup (path
);
5249 size_t tmp_path_len
= strlen (tmp_path
);
5251 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5253 tmp_path
[tmp_path_len
- 1] = 0;
5255 tmp_path_len
= strlen (tmp_path
);
5258 char **files
= NULL
;
5264 if ((d
= opendir (tmp_path
)) != NULL
)
5268 while ((de
= readdir (d
)) != NULL
)
5270 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5272 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5274 char *path_file
= (char *) mymalloc (path_size
+ 1);
5276 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5278 path_file
[path_size
] = 0;
5282 if ((d_test
= opendir (path_file
)) != NULL
)
5290 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5294 files
[num_files
- 1] = path_file
;
5300 else if (errno
== ENOTDIR
)
5302 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5306 files
[num_files
- 1] = mystrdup (path
);
5309 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5313 files
[num_files
- 1] = NULL
;
5320 int count_dictionaries (char **dictionary_files
)
5322 if (dictionary_files
== NULL
) return 0;
5326 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5334 char *stroptitype (const uint opti_type
)
5338 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5339 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5340 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5341 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5342 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5343 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5344 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5345 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5346 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5347 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5348 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5349 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5350 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5351 case OPTI_TYPE_SCALAR_MODE
: return ((char *) OPTI_STR_SCALAR_MODE
); break;
5352 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5358 char *strparser (const uint parser_status
)
5360 switch (parser_status
)
5362 case PARSER_OK
: return ((char *) PA_000
); break;
5363 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5364 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5365 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5366 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5367 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5368 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5369 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5370 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5371 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5372 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5373 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5374 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5375 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5376 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5377 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5378 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5381 return ((char *) PA_255
);
5384 char *strhashtype (const uint hash_mode
)
5388 case 0: return ((char *) HT_00000
); break;
5389 case 10: return ((char *) HT_00010
); break;
5390 case 11: return ((char *) HT_00011
); break;
5391 case 12: return ((char *) HT_00012
); break;
5392 case 20: return ((char *) HT_00020
); break;
5393 case 21: return ((char *) HT_00021
); break;
5394 case 22: return ((char *) HT_00022
); break;
5395 case 23: return ((char *) HT_00023
); break;
5396 case 30: return ((char *) HT_00030
); break;
5397 case 40: return ((char *) HT_00040
); break;
5398 case 50: return ((char *) HT_00050
); break;
5399 case 60: return ((char *) HT_00060
); break;
5400 case 100: return ((char *) HT_00100
); break;
5401 case 101: return ((char *) HT_00101
); break;
5402 case 110: return ((char *) HT_00110
); break;
5403 case 111: return ((char *) HT_00111
); break;
5404 case 112: return ((char *) HT_00112
); break;
5405 case 120: return ((char *) HT_00120
); break;
5406 case 121: return ((char *) HT_00121
); break;
5407 case 122: return ((char *) HT_00122
); break;
5408 case 124: return ((char *) HT_00124
); break;
5409 case 130: return ((char *) HT_00130
); break;
5410 case 131: return ((char *) HT_00131
); break;
5411 case 132: return ((char *) HT_00132
); break;
5412 case 133: return ((char *) HT_00133
); break;
5413 case 140: return ((char *) HT_00140
); break;
5414 case 141: return ((char *) HT_00141
); break;
5415 case 150: return ((char *) HT_00150
); break;
5416 case 160: return ((char *) HT_00160
); break;
5417 case 190: return ((char *) HT_00190
); break;
5418 case 200: return ((char *) HT_00200
); break;
5419 case 300: return ((char *) HT_00300
); break;
5420 case 400: return ((char *) HT_00400
); break;
5421 case 500: return ((char *) HT_00500
); break;
5422 case 501: return ((char *) HT_00501
); break;
5423 case 900: return ((char *) HT_00900
); break;
5424 case 910: return ((char *) HT_00910
); break;
5425 case 1000: return ((char *) HT_01000
); break;
5426 case 1100: return ((char *) HT_01100
); break;
5427 case 1400: return ((char *) HT_01400
); break;
5428 case 1410: return ((char *) HT_01410
); break;
5429 case 1420: return ((char *) HT_01420
); break;
5430 case 1421: return ((char *) HT_01421
); break;
5431 case 1430: return ((char *) HT_01430
); break;
5432 case 1440: return ((char *) HT_01440
); break;
5433 case 1441: return ((char *) HT_01441
); break;
5434 case 1450: return ((char *) HT_01450
); break;
5435 case 1460: return ((char *) HT_01460
); break;
5436 case 1500: return ((char *) HT_01500
); break;
5437 case 1600: return ((char *) HT_01600
); break;
5438 case 1700: return ((char *) HT_01700
); break;
5439 case 1710: return ((char *) HT_01710
); break;
5440 case 1711: return ((char *) HT_01711
); break;
5441 case 1720: return ((char *) HT_01720
); break;
5442 case 1722: return ((char *) HT_01722
); break;
5443 case 1730: return ((char *) HT_01730
); break;
5444 case 1731: return ((char *) HT_01731
); break;
5445 case 1740: return ((char *) HT_01740
); break;
5446 case 1750: return ((char *) HT_01750
); break;
5447 case 1760: return ((char *) HT_01760
); break;
5448 case 1800: return ((char *) HT_01800
); break;
5449 case 2100: return ((char *) HT_02100
); break;
5450 case 2400: return ((char *) HT_02400
); break;
5451 case 2410: return ((char *) HT_02410
); break;
5452 case 2500: return ((char *) HT_02500
); break;
5453 case 2600: return ((char *) HT_02600
); break;
5454 case 2611: return ((char *) HT_02611
); break;
5455 case 2612: return ((char *) HT_02612
); break;
5456 case 2711: return ((char *) HT_02711
); break;
5457 case 2811: return ((char *) HT_02811
); break;
5458 case 3000: return ((char *) HT_03000
); break;
5459 case 3100: return ((char *) HT_03100
); break;
5460 case 3200: return ((char *) HT_03200
); break;
5461 case 3710: return ((char *) HT_03710
); break;
5462 case 3711: return ((char *) HT_03711
); break;
5463 case 3800: return ((char *) HT_03800
); break;
5464 case 4300: return ((char *) HT_04300
); break;
5465 case 4400: return ((char *) HT_04400
); break;
5466 case 4500: return ((char *) HT_04500
); break;
5467 case 4700: return ((char *) HT_04700
); break;
5468 case 4800: return ((char *) HT_04800
); break;
5469 case 4900: return ((char *) HT_04900
); break;
5470 case 5000: return ((char *) HT_05000
); break;
5471 case 5100: return ((char *) HT_05100
); break;
5472 case 5200: return ((char *) HT_05200
); break;
5473 case 5300: return ((char *) HT_05300
); break;
5474 case 5400: return ((char *) HT_05400
); break;
5475 case 5500: return ((char *) HT_05500
); break;
5476 case 5600: return ((char *) HT_05600
); break;
5477 case 5700: return ((char *) HT_05700
); break;
5478 case 5800: return ((char *) HT_05800
); break;
5479 case 6000: return ((char *) HT_06000
); break;
5480 case 6100: return ((char *) HT_06100
); break;
5481 case 6211: return ((char *) HT_06211
); break;
5482 case 6212: return ((char *) HT_06212
); break;
5483 case 6213: return ((char *) HT_06213
); break;
5484 case 6221: return ((char *) HT_06221
); break;
5485 case 6222: return ((char *) HT_06222
); break;
5486 case 6223: return ((char *) HT_06223
); break;
5487 case 6231: return ((char *) HT_06231
); break;
5488 case 6232: return ((char *) HT_06232
); break;
5489 case 6233: return ((char *) HT_06233
); break;
5490 case 6241: return ((char *) HT_06241
); break;
5491 case 6242: return ((char *) HT_06242
); break;
5492 case 6243: return ((char *) HT_06243
); break;
5493 case 6300: return ((char *) HT_06300
); break;
5494 case 6400: return ((char *) HT_06400
); break;
5495 case 6500: return ((char *) HT_06500
); break;
5496 case 6600: return ((char *) HT_06600
); break;
5497 case 6700: return ((char *) HT_06700
); break;
5498 case 6800: return ((char *) HT_06800
); break;
5499 case 6900: return ((char *) HT_06900
); break;
5500 case 7100: return ((char *) HT_07100
); break;
5501 case 7200: return ((char *) HT_07200
); break;
5502 case 7300: return ((char *) HT_07300
); break;
5503 case 7400: return ((char *) HT_07400
); break;
5504 case 7500: return ((char *) HT_07500
); break;
5505 case 7600: return ((char *) HT_07600
); break;
5506 case 7700: return ((char *) HT_07700
); break;
5507 case 7800: return ((char *) HT_07800
); break;
5508 case 7900: return ((char *) HT_07900
); break;
5509 case 8000: return ((char *) HT_08000
); break;
5510 case 8100: return ((char *) HT_08100
); break;
5511 case 8200: return ((char *) HT_08200
); break;
5512 case 8300: return ((char *) HT_08300
); break;
5513 case 8400: return ((char *) HT_08400
); break;
5514 case 8500: return ((char *) HT_08500
); break;
5515 case 8600: return ((char *) HT_08600
); break;
5516 case 8700: return ((char *) HT_08700
); break;
5517 case 8800: return ((char *) HT_08800
); break;
5518 case 8900: return ((char *) HT_08900
); break;
5519 case 9000: return ((char *) HT_09000
); break;
5520 case 9100: return ((char *) HT_09100
); break;
5521 case 9200: return ((char *) HT_09200
); break;
5522 case 9300: return ((char *) HT_09300
); break;
5523 case 9400: return ((char *) HT_09400
); break;
5524 case 9500: return ((char *) HT_09500
); break;
5525 case 9600: return ((char *) HT_09600
); break;
5526 case 9700: return ((char *) HT_09700
); break;
5527 case 9710: return ((char *) HT_09710
); break;
5528 case 9720: return ((char *) HT_09720
); break;
5529 case 9800: return ((char *) HT_09800
); break;
5530 case 9810: return ((char *) HT_09810
); break;
5531 case 9820: return ((char *) HT_09820
); break;
5532 case 9900: return ((char *) HT_09900
); break;
5533 case 10000: return ((char *) HT_10000
); break;
5534 case 10100: return ((char *) HT_10100
); break;
5535 case 10200: return ((char *) HT_10200
); break;
5536 case 10300: return ((char *) HT_10300
); break;
5537 case 10400: return ((char *) HT_10400
); break;
5538 case 10410: return ((char *) HT_10410
); break;
5539 case 10420: return ((char *) HT_10420
); break;
5540 case 10500: return ((char *) HT_10500
); break;
5541 case 10600: return ((char *) HT_10600
); break;
5542 case 10700: return ((char *) HT_10700
); break;
5543 case 10800: return ((char *) HT_10800
); break;
5544 case 10900: return ((char *) HT_10900
); break;
5545 case 11000: return ((char *) HT_11000
); break;
5546 case 11100: return ((char *) HT_11100
); break;
5547 case 11200: return ((char *) HT_11200
); break;
5548 case 11300: return ((char *) HT_11300
); break;
5549 case 11400: return ((char *) HT_11400
); break;
5550 case 11500: return ((char *) HT_11500
); break;
5551 case 11600: return ((char *) HT_11600
); break;
5552 case 11700: return ((char *) HT_11700
); break;
5553 case 11800: return ((char *) HT_11800
); break;
5554 case 11900: return ((char *) HT_11900
); break;
5555 case 12000: return ((char *) HT_12000
); break;
5556 case 12100: return ((char *) HT_12100
); break;
5557 case 12200: return ((char *) HT_12200
); break;
5558 case 12300: return ((char *) HT_12300
); break;
5559 case 12400: return ((char *) HT_12400
); break;
5560 case 12500: return ((char *) HT_12500
); break;
5561 case 12600: return ((char *) HT_12600
); break;
5562 case 12700: return ((char *) HT_12700
); break;
5563 case 12800: return ((char *) HT_12800
); break;
5566 return ((char *) "Unknown");
5569 char *strstatus (const uint devices_status
)
5571 switch (devices_status
)
5573 case STATUS_INIT
: return ((char *) ST_0000
); break;
5574 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5575 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5576 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5577 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5578 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5579 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5580 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5583 return ((char *) "Unknown");
5586 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5588 uint hash_type
= data
.hash_type
;
5589 uint hash_mode
= data
.hash_mode
;
5590 uint salt_type
= data
.salt_type
;
5591 uint opts_type
= data
.opts_type
;
5592 uint opti_type
= data
.opti_type
;
5593 uint dgst_size
= data
.dgst_size
;
5595 char *hashfile
= data
.hashfile
;
5599 uint digest_buf
[64];
5601 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5603 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5605 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5607 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5613 case HASH_TYPE_DESCRYPT
:
5614 FP (digest_buf
[1], digest_buf
[0], tt
);
5617 case HASH_TYPE_DESRACF
:
5618 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5619 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5621 FP (digest_buf
[1], digest_buf
[0], tt
);
5625 FP (digest_buf
[1], digest_buf
[0], tt
);
5628 case HASH_TYPE_NETNTLM
:
5629 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5630 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5631 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5632 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5634 FP (digest_buf
[1], digest_buf
[0], tt
);
5635 FP (digest_buf
[3], digest_buf
[2], tt
);
5638 case HASH_TYPE_BSDICRYPT
:
5639 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5640 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5642 FP (digest_buf
[1], digest_buf
[0], tt
);
5647 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5652 digest_buf
[0] += MD4M_A
;
5653 digest_buf
[1] += MD4M_B
;
5654 digest_buf
[2] += MD4M_C
;
5655 digest_buf
[3] += MD4M_D
;
5659 digest_buf
[0] += MD5M_A
;
5660 digest_buf
[1] += MD5M_B
;
5661 digest_buf
[2] += MD5M_C
;
5662 digest_buf
[3] += MD5M_D
;
5665 case HASH_TYPE_SHA1
:
5666 digest_buf
[0] += SHA1M_A
;
5667 digest_buf
[1] += SHA1M_B
;
5668 digest_buf
[2] += SHA1M_C
;
5669 digest_buf
[3] += SHA1M_D
;
5670 digest_buf
[4] += SHA1M_E
;
5673 case HASH_TYPE_SHA256
:
5674 digest_buf
[0] += SHA256M_A
;
5675 digest_buf
[1] += SHA256M_B
;
5676 digest_buf
[2] += SHA256M_C
;
5677 digest_buf
[3] += SHA256M_D
;
5678 digest_buf
[4] += SHA256M_E
;
5679 digest_buf
[5] += SHA256M_F
;
5680 digest_buf
[6] += SHA256M_G
;
5681 digest_buf
[7] += SHA256M_H
;
5684 case HASH_TYPE_SHA384
:
5685 digest_buf64
[0] += SHA384M_A
;
5686 digest_buf64
[1] += SHA384M_B
;
5687 digest_buf64
[2] += SHA384M_C
;
5688 digest_buf64
[3] += SHA384M_D
;
5689 digest_buf64
[4] += SHA384M_E
;
5690 digest_buf64
[5] += SHA384M_F
;
5691 digest_buf64
[6] += 0;
5692 digest_buf64
[7] += 0;
5695 case HASH_TYPE_SHA512
:
5696 digest_buf64
[0] += SHA512M_A
;
5697 digest_buf64
[1] += SHA512M_B
;
5698 digest_buf64
[2] += SHA512M_C
;
5699 digest_buf64
[3] += SHA512M_D
;
5700 digest_buf64
[4] += SHA512M_E
;
5701 digest_buf64
[5] += SHA512M_F
;
5702 digest_buf64
[6] += SHA512M_G
;
5703 digest_buf64
[7] += SHA512M_H
;
5708 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5710 if (dgst_size
== DGST_SIZE_4_2
)
5712 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5714 else if (dgst_size
== DGST_SIZE_4_4
)
5716 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5718 else if (dgst_size
== DGST_SIZE_4_5
)
5720 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5722 else if (dgst_size
== DGST_SIZE_4_6
)
5724 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5726 else if (dgst_size
== DGST_SIZE_4_8
)
5728 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5730 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5732 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5734 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5736 else if (hash_type
== HASH_TYPE_SHA384
)
5738 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5740 else if (hash_type
== HASH_TYPE_SHA512
)
5742 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5744 else if (hash_type
== HASH_TYPE_GOST
)
5746 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5749 else if (dgst_size
== DGST_SIZE_4_64
)
5751 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5753 else if (dgst_size
== DGST_SIZE_8_25
)
5755 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5759 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5760 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5761 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5767 memset (&salt
, 0, sizeof (salt_t
));
5769 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5771 char *ptr
= (char *) salt
.salt_buf
;
5773 uint len
= salt
.salt_len
;
5775 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5781 case HASH_TYPE_NETNTLM
:
5783 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5784 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5786 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5792 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5794 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5802 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5804 uint max
= salt
.salt_len
/ 4;
5808 for (uint i
= 0; i
< max
; i
++)
5810 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5814 if (opts_type
& OPTS_TYPE_ST_HEX
)
5818 memset (tmp
, 0, sizeof (tmp
));
5820 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5822 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5827 memcpy (ptr
, tmp
, len
);
5830 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5832 memset (ptr
+ len
, 0, memset_size
);
5834 salt
.salt_len
= len
;
5838 // some modes require special encoding
5841 uint out_buf_plain
[256];
5842 uint out_buf_salt
[256];
5846 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5847 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5849 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5851 char *ptr_plain
= (char *) out_buf_plain
;
5852 char *ptr_salt
= (char *) out_buf_salt
;
5854 if (hash_mode
== 22)
5858 memset (username
, 0, sizeof (username
));
5860 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5862 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5864 uint16_t *ptr
= (uint16_t *) digest_buf
;
5866 tmp_buf
[ 0] = sig
[0];
5867 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5868 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5869 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5870 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5871 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5872 tmp_buf
[ 6] = sig
[1];
5873 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5874 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5875 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5876 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5877 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5878 tmp_buf
[12] = sig
[2];
5879 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5880 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5881 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5882 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5883 tmp_buf
[17] = sig
[3];
5884 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5885 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5886 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5887 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5888 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5889 tmp_buf
[23] = sig
[4];
5890 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5891 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5892 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5893 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5894 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5895 tmp_buf
[29] = sig
[5];
5897 snprintf (out_buf
, len
-1, "%s:%s",
5901 else if (hash_mode
== 23)
5903 // do not show the \nskyper\n part in output
5905 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5907 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5909 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5916 else if (hash_mode
== 101)
5918 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5920 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5921 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5922 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5923 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5924 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5926 memcpy (tmp_buf
, digest_buf
, 20);
5928 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5930 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5932 else if (hash_mode
== 111)
5934 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5936 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5937 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5938 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5939 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5940 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5942 memcpy (tmp_buf
, digest_buf
, 20);
5943 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5945 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5947 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
5949 else if (hash_mode
== 122)
5951 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
5952 (unsigned char *) salt
.salt_buf
,
5959 else if (hash_mode
== 124)
5961 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
5962 (unsigned char *) salt
.salt_buf
,
5969 else if (hash_mode
== 131)
5971 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
5972 (unsigned char *) salt
.salt_buf
,
5980 else if (hash_mode
== 132)
5982 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
5983 (unsigned char *) salt
.salt_buf
,
5990 else if (hash_mode
== 133)
5992 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5994 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5995 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5996 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5997 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5998 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6000 memcpy (tmp_buf
, digest_buf
, 20);
6002 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6004 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6006 else if (hash_mode
== 141)
6008 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6010 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6012 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6014 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6016 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6017 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6018 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6019 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6020 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6022 memcpy (tmp_buf
, digest_buf
, 20);
6024 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6028 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6030 else if (hash_mode
== 400)
6032 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6034 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6035 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6036 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6037 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6039 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6041 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6043 else if (hash_mode
== 500)
6045 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6047 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6048 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6049 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6050 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6052 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6054 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6056 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6060 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6063 else if (hash_mode
== 501)
6065 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6067 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6068 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6070 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6072 else if (hash_mode
== 1421)
6074 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6076 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6092 else if (hash_mode
== 1441)
6094 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6096 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6098 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6100 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6102 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6103 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6104 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6105 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6106 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6107 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6108 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6109 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6111 memcpy (tmp_buf
, digest_buf
, 32);
6113 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6117 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6119 else if (hash_mode
== 1500)
6121 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6122 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6123 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6124 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6125 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6127 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6129 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6131 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6132 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6134 memcpy (tmp_buf
, digest_buf
, 8);
6136 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6138 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6142 else if (hash_mode
== 1600)
6144 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6146 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6147 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6148 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6149 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6151 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6153 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6155 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6159 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6162 else if (hash_mode
== 1711)
6164 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6166 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6167 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6168 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6169 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6170 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6171 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6172 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6173 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6175 memcpy (tmp_buf
, digest_buf
, 64);
6176 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6178 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6180 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6182 else if (hash_mode
== 1722)
6184 uint
*ptr
= digest_buf
;
6186 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6187 (unsigned char *) salt
.salt_buf
,
6197 else if (hash_mode
== 1731)
6199 uint
*ptr
= digest_buf
;
6201 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6202 (unsigned char *) salt
.salt_buf
,
6212 else if (hash_mode
== 1800)
6216 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6217 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6218 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6219 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6220 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6221 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6222 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6223 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6225 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6227 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6229 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6233 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6236 else if (hash_mode
== 2100)
6240 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6242 salt
.salt_iter
+ 1);
6244 uint signature_len
= strlen (out_buf
);
6246 pos
+= signature_len
;
6247 len
-= signature_len
;
6249 char *salt_ptr
= (char *) salt
.salt_buf
;
6251 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6253 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6254 byte_swap_32 (digest_buf
[0]),
6255 byte_swap_32 (digest_buf
[1]),
6256 byte_swap_32 (digest_buf
[2]),
6257 byte_swap_32 (digest_buf
[3]));
6259 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6261 memcpy (tmp_buf
, digest_buf
, 16);
6263 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6265 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6266 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6267 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6268 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6270 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6271 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6272 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6273 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6275 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6276 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6277 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6278 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6280 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6281 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6282 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6283 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6285 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6286 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6287 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6288 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6292 else if (hash_mode
== 2500)
6294 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6296 wpa_t
*wpa
= &wpas
[salt_pos
];
6300 char *pke_ptr
= (char *) pke
;
6302 for (uint i
= 0; i
< 25; i
++)
6304 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6307 unsigned char mac1
[6];
6308 unsigned char mac2
[6];
6310 memcpy (mac1
, pke_ptr
+ 23, 6);
6311 memcpy (mac2
, pke_ptr
+ 29, 6);
6313 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6314 (char *) salt
.salt_buf
,
6328 else if (hash_mode
== 4400)
6330 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6331 byte_swap_32 (digest_buf
[0]),
6332 byte_swap_32 (digest_buf
[1]),
6333 byte_swap_32 (digest_buf
[2]),
6334 byte_swap_32 (digest_buf
[3]));
6336 else if (hash_mode
== 4700)
6338 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6339 byte_swap_32 (digest_buf
[0]),
6340 byte_swap_32 (digest_buf
[1]),
6341 byte_swap_32 (digest_buf
[2]),
6342 byte_swap_32 (digest_buf
[3]),
6343 byte_swap_32 (digest_buf
[4]));
6345 else if (hash_mode
== 4800)
6347 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6349 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6354 byte_swap_32 (salt
.salt_buf
[0]),
6355 byte_swap_32 (salt
.salt_buf
[1]),
6356 byte_swap_32 (salt
.salt_buf
[2]),
6357 byte_swap_32 (salt
.salt_buf
[3]),
6360 else if (hash_mode
== 4900)
6362 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6363 byte_swap_32 (digest_buf
[0]),
6364 byte_swap_32 (digest_buf
[1]),
6365 byte_swap_32 (digest_buf
[2]),
6366 byte_swap_32 (digest_buf
[3]),
6367 byte_swap_32 (digest_buf
[4]));
6369 else if (hash_mode
== 5100)
6371 snprintf (out_buf
, len
-1, "%08x%08x",
6375 else if (hash_mode
== 5200)
6377 snprintf (out_buf
, len
-1, "%s", hashfile
);
6379 else if (hash_mode
== 5300)
6381 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6383 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6385 int buf_len
= len
-1;
6389 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6391 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6393 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6395 snprintf (out_buf
, buf_len
, ":");
6401 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6409 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6411 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6413 if ((i
== 0) || (i
== 5))
6415 snprintf (out_buf
, buf_len
, ":");
6421 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6429 for (uint i
= 0; i
< 4; i
++)
6433 snprintf (out_buf
, buf_len
, ":");
6439 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6445 else if (hash_mode
== 5400)
6447 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6449 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6451 int buf_len
= len
-1;
6455 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6457 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6459 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6461 snprintf (out_buf
, buf_len
, ":");
6467 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6475 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6477 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6479 if ((i
== 0) || (i
== 5))
6481 snprintf (out_buf
, buf_len
, ":");
6487 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6495 for (uint i
= 0; i
< 5; i
++)
6499 snprintf (out_buf
, buf_len
, ":");
6505 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6511 else if (hash_mode
== 5500)
6513 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6515 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6518 char domain_buf
[64];
6519 char srvchall_buf
[1024];
6520 char clichall_buf
[1024];
6522 memset (user_buf
, 0, sizeof (user_buf
));
6523 memset (domain_buf
, 0, sizeof (domain_buf
));
6524 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6525 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6527 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6529 char *ptr
= (char *) netntlm
->userdomain_buf
;
6531 user_buf
[i
] = ptr
[j
];
6534 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6536 char *ptr
= (char *) netntlm
->userdomain_buf
;
6538 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6541 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6543 char *ptr
= (char *) netntlm
->chall_buf
;
6545 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6548 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6550 char *ptr
= (char *) netntlm
->chall_buf
;
6552 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6555 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6563 byte_swap_32 (salt
.salt_buf_pc
[0]),
6564 byte_swap_32 (salt
.salt_buf_pc
[1]),
6567 else if (hash_mode
== 5600)
6569 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6571 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6574 char domain_buf
[64];
6575 char srvchall_buf
[1024];
6576 char clichall_buf
[1024];
6578 memset (user_buf
, 0, sizeof (user_buf
));
6579 memset (domain_buf
, 0, sizeof (domain_buf
));
6580 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6581 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6583 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6585 char *ptr
= (char *) netntlm
->userdomain_buf
;
6587 user_buf
[i
] = ptr
[j
];
6590 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6592 char *ptr
= (char *) netntlm
->userdomain_buf
;
6594 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6597 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6599 char *ptr
= (char *) netntlm
->chall_buf
;
6601 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6604 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6606 char *ptr
= (char *) netntlm
->chall_buf
;
6608 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6611 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6621 else if (hash_mode
== 5700)
6623 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6625 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6626 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6627 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6628 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6629 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6630 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6631 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6632 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6634 memcpy (tmp_buf
, digest_buf
, 32);
6636 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6640 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6642 else if (hash_mode
== 5800)
6644 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6645 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6646 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6647 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6648 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6650 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6657 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6659 snprintf (out_buf
, len
-1, "%s", hashfile
);
6661 else if (hash_mode
== 6300)
6663 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6665 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6666 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6667 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6668 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6670 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6672 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6674 else if (hash_mode
== 6400)
6676 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6678 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6680 else if (hash_mode
== 6500)
6682 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6684 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6686 else if (hash_mode
== 6600)
6688 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6690 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6692 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6693 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6695 uint buf_len
= len
- 1;
6697 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6700 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6702 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6707 else if (hash_mode
== 6700)
6709 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6711 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6713 else if (hash_mode
== 6800)
6715 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6717 else if (hash_mode
== 7100)
6719 uint
*ptr
= digest_buf
;
6721 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6723 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6727 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6728 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6729 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6730 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6731 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6732 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6733 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6734 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6736 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",
6737 SIGNATURE_SHA512OSX
,
6739 esalt
[ 0], esalt
[ 1],
6740 esalt
[ 2], esalt
[ 3],
6741 esalt
[ 4], esalt
[ 5],
6742 esalt
[ 6], esalt
[ 7],
6750 ptr
[15], ptr
[14]);
6752 else if (hash_mode
== 7200)
6754 uint
*ptr
= digest_buf
;
6756 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6758 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6762 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6764 len_used
= strlen (out_buf
);
6766 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6768 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6770 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6773 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",
6781 ptr
[15], ptr
[14]);
6783 else if (hash_mode
== 7300)
6785 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6787 rakp_t
*rakp
= &rakps
[salt_pos
];
6789 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6791 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6794 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6801 else if (hash_mode
== 7400)
6803 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6805 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6806 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6807 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6808 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6809 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6810 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6811 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6812 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6814 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6816 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6818 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6822 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6825 else if (hash_mode
== 7500)
6827 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6829 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6831 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6832 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6836 char *ptr_data
= data
;
6838 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6840 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6843 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6845 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6850 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6852 (char *) krb5pa
->user
,
6853 (char *) krb5pa
->realm
,
6854 (char *) krb5pa
->salt
,
6857 else if (hash_mode
== 7700)
6859 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6860 (char *) salt
.salt_buf
,
6864 else if (hash_mode
== 7800)
6866 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6867 (char *) salt
.salt_buf
,
6874 else if (hash_mode
== 7900)
6876 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6880 char *tmp
= (char *) salt
.salt_buf_pc
;
6882 ptr_plain
[42] = tmp
[0];
6888 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6890 else if (hash_mode
== 8000)
6892 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6893 (unsigned char *) salt
.salt_buf
,
6903 else if (hash_mode
== 8100)
6905 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6906 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6908 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6909 (unsigned char *) salt
.salt_buf
,
6916 else if (hash_mode
== 8200)
6918 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6920 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6922 char data_buf
[4096];
6924 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6926 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6929 data_buf
[cloudkey
->data_len
* 2] = 0;
6931 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6932 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6933 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6934 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6935 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6936 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6937 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6938 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6940 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6941 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6942 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6943 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6945 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
6961 else if (hash_mode
== 8300)
6965 char digest_buf_c
[33];
6967 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
6969 digest_buf_c
[32] = 0;
6973 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
6975 char domain_buf_c
[33];
6977 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
6979 for (uint i
= 0; i
< salt_pc_len
; i
++)
6981 const char next
= domain_buf_c
[i
];
6983 domain_buf_c
[i
] = '.';
6988 domain_buf_c
[salt_pc_len
] = 0;
6992 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
6994 else if (hash_mode
== 8500)
6996 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
6998 else if (hash_mode
== 2612)
7000 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7002 (char *) salt
.salt_buf
,
7008 else if (hash_mode
== 3711)
7010 char *salt_ptr
= (char *) salt
.salt_buf
;
7012 salt_ptr
[salt
.salt_len
- 1] = 0;
7014 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7015 SIGNATURE_MEDIAWIKI_B
,
7022 else if (hash_mode
== 8800)
7024 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7026 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7030 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7032 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7037 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7038 SIGNATURE_ANDROIDFDE
,
7039 byte_swap_32 (salt
.salt_buf
[0]),
7040 byte_swap_32 (salt
.salt_buf
[1]),
7041 byte_swap_32 (salt
.salt_buf
[2]),
7042 byte_swap_32 (salt
.salt_buf
[3]),
7043 byte_swap_32 (digest_buf
[0]),
7044 byte_swap_32 (digest_buf
[1]),
7045 byte_swap_32 (digest_buf
[2]),
7046 byte_swap_32 (digest_buf
[3]),
7049 else if (hash_mode
== 8900)
7051 uint N
= salt
.scrypt_N
;
7052 uint r
= salt
.scrypt_r
;
7053 uint p
= salt
.scrypt_p
;
7055 char base64_salt
[32];
7057 memset (base64_salt
, 0, 32);
7059 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7061 memset (tmp_buf
, 0, 46);
7063 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7064 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7065 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7066 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7067 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7068 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7069 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7070 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7071 digest_buf
[8] = 0; // needed for base64_encode ()
7073 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7075 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7083 else if (hash_mode
== 9000)
7085 snprintf (out_buf
, len
-1, "%s", hashfile
);
7087 else if (hash_mode
== 9200)
7091 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7093 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7095 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7099 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7100 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7101 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7102 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7103 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7104 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7105 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7106 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7107 digest_buf
[8] = 0; // needed for base64_encode ()
7110 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7112 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7113 tmp_buf
[43] = 0; // cut it here
7117 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7119 else if (hash_mode
== 9300)
7121 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7122 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7123 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7124 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7125 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7126 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7127 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7128 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7129 digest_buf
[8] = 0; // needed for base64_encode ()
7132 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7134 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7135 tmp_buf
[43] = 0; // cut it here
7137 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7139 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7141 else if (hash_mode
== 9400)
7143 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7145 office2007_t
*office2007
= &office2007s
[salt_pos
];
7147 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7148 SIGNATURE_OFFICE2007
,
7151 office2007
->keySize
,
7157 office2007
->encryptedVerifier
[0],
7158 office2007
->encryptedVerifier
[1],
7159 office2007
->encryptedVerifier
[2],
7160 office2007
->encryptedVerifier
[3],
7161 office2007
->encryptedVerifierHash
[0],
7162 office2007
->encryptedVerifierHash
[1],
7163 office2007
->encryptedVerifierHash
[2],
7164 office2007
->encryptedVerifierHash
[3],
7165 office2007
->encryptedVerifierHash
[4]);
7167 else if (hash_mode
== 9500)
7169 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7171 office2010_t
*office2010
= &office2010s
[salt_pos
];
7173 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,
7179 office2010
->encryptedVerifier
[0],
7180 office2010
->encryptedVerifier
[1],
7181 office2010
->encryptedVerifier
[2],
7182 office2010
->encryptedVerifier
[3],
7183 office2010
->encryptedVerifierHash
[0],
7184 office2010
->encryptedVerifierHash
[1],
7185 office2010
->encryptedVerifierHash
[2],
7186 office2010
->encryptedVerifierHash
[3],
7187 office2010
->encryptedVerifierHash
[4],
7188 office2010
->encryptedVerifierHash
[5],
7189 office2010
->encryptedVerifierHash
[6],
7190 office2010
->encryptedVerifierHash
[7]);
7192 else if (hash_mode
== 9600)
7194 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7196 office2013_t
*office2013
= &office2013s
[salt_pos
];
7198 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,
7204 office2013
->encryptedVerifier
[0],
7205 office2013
->encryptedVerifier
[1],
7206 office2013
->encryptedVerifier
[2],
7207 office2013
->encryptedVerifier
[3],
7208 office2013
->encryptedVerifierHash
[0],
7209 office2013
->encryptedVerifierHash
[1],
7210 office2013
->encryptedVerifierHash
[2],
7211 office2013
->encryptedVerifierHash
[3],
7212 office2013
->encryptedVerifierHash
[4],
7213 office2013
->encryptedVerifierHash
[5],
7214 office2013
->encryptedVerifierHash
[6],
7215 office2013
->encryptedVerifierHash
[7]);
7217 else if (hash_mode
== 9700)
7219 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7221 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7223 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7224 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7225 byte_swap_32 (salt
.salt_buf
[0]),
7226 byte_swap_32 (salt
.salt_buf
[1]),
7227 byte_swap_32 (salt
.salt_buf
[2]),
7228 byte_swap_32 (salt
.salt_buf
[3]),
7229 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7230 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7231 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7232 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7233 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7234 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7235 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7236 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7238 else if (hash_mode
== 9710)
7240 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7242 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7244 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7245 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7246 byte_swap_32 (salt
.salt_buf
[0]),
7247 byte_swap_32 (salt
.salt_buf
[1]),
7248 byte_swap_32 (salt
.salt_buf
[2]),
7249 byte_swap_32 (salt
.salt_buf
[3]),
7250 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7251 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7252 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7253 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7254 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7255 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7256 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7257 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7259 else if (hash_mode
== 9720)
7261 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7263 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7265 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7267 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7268 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7269 byte_swap_32 (salt
.salt_buf
[0]),
7270 byte_swap_32 (salt
.salt_buf
[1]),
7271 byte_swap_32 (salt
.salt_buf
[2]),
7272 byte_swap_32 (salt
.salt_buf
[3]),
7273 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7274 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7275 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7276 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7277 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7278 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7279 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7280 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7287 else if (hash_mode
== 9800)
7289 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7291 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7293 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7294 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7299 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7300 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7301 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7302 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7303 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7304 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7305 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7306 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7307 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7309 else if (hash_mode
== 9810)
7311 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7313 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7315 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7316 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7321 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7322 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7323 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7324 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7325 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7326 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7327 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7328 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7329 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7331 else if (hash_mode
== 9820)
7333 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7335 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7337 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7339 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7340 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7345 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7346 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7347 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7348 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7349 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7350 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7351 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7352 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7353 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7360 else if (hash_mode
== 10000)
7364 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7366 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7368 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7372 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7373 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7374 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7375 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7376 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7377 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7378 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7379 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7380 digest_buf
[8] = 0; // needed for base64_encode ()
7383 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7385 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7389 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7391 else if (hash_mode
== 10100)
7393 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7398 byte_swap_32 (salt
.salt_buf
[0]),
7399 byte_swap_32 (salt
.salt_buf
[1]),
7400 byte_swap_32 (salt
.salt_buf
[2]),
7401 byte_swap_32 (salt
.salt_buf
[3]));
7403 else if (hash_mode
== 10200)
7405 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7407 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7411 char challenge
[100];
7413 memset (challenge
, 0, sizeof (challenge
));
7415 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7421 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7422 (char *) cram_md5
->user
,
7430 memset (response
, 0, sizeof (response
));
7432 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7434 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7436 else if (hash_mode
== 10300)
7440 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7442 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7443 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7445 uint tmp_len
= 20 + salt
.salt_len
;
7449 char base64_encoded
[100];
7451 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7453 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7455 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7457 else if (hash_mode
== 10400)
7459 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7461 pdf_t
*pdf
= &pdfs
[salt_pos
];
7463 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",
7471 byte_swap_32 (pdf
->id_buf
[0]),
7472 byte_swap_32 (pdf
->id_buf
[1]),
7473 byte_swap_32 (pdf
->id_buf
[2]),
7474 byte_swap_32 (pdf
->id_buf
[3]),
7476 byte_swap_32 (pdf
->u_buf
[0]),
7477 byte_swap_32 (pdf
->u_buf
[1]),
7478 byte_swap_32 (pdf
->u_buf
[2]),
7479 byte_swap_32 (pdf
->u_buf
[3]),
7480 byte_swap_32 (pdf
->u_buf
[4]),
7481 byte_swap_32 (pdf
->u_buf
[5]),
7482 byte_swap_32 (pdf
->u_buf
[6]),
7483 byte_swap_32 (pdf
->u_buf
[7]),
7485 byte_swap_32 (pdf
->o_buf
[0]),
7486 byte_swap_32 (pdf
->o_buf
[1]),
7487 byte_swap_32 (pdf
->o_buf
[2]),
7488 byte_swap_32 (pdf
->o_buf
[3]),
7489 byte_swap_32 (pdf
->o_buf
[4]),
7490 byte_swap_32 (pdf
->o_buf
[5]),
7491 byte_swap_32 (pdf
->o_buf
[6]),
7492 byte_swap_32 (pdf
->o_buf
[7])
7495 else if (hash_mode
== 10410)
7497 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7499 pdf_t
*pdf
= &pdfs
[salt_pos
];
7501 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",
7509 byte_swap_32 (pdf
->id_buf
[0]),
7510 byte_swap_32 (pdf
->id_buf
[1]),
7511 byte_swap_32 (pdf
->id_buf
[2]),
7512 byte_swap_32 (pdf
->id_buf
[3]),
7514 byte_swap_32 (pdf
->u_buf
[0]),
7515 byte_swap_32 (pdf
->u_buf
[1]),
7516 byte_swap_32 (pdf
->u_buf
[2]),
7517 byte_swap_32 (pdf
->u_buf
[3]),
7518 byte_swap_32 (pdf
->u_buf
[4]),
7519 byte_swap_32 (pdf
->u_buf
[5]),
7520 byte_swap_32 (pdf
->u_buf
[6]),
7521 byte_swap_32 (pdf
->u_buf
[7]),
7523 byte_swap_32 (pdf
->o_buf
[0]),
7524 byte_swap_32 (pdf
->o_buf
[1]),
7525 byte_swap_32 (pdf
->o_buf
[2]),
7526 byte_swap_32 (pdf
->o_buf
[3]),
7527 byte_swap_32 (pdf
->o_buf
[4]),
7528 byte_swap_32 (pdf
->o_buf
[5]),
7529 byte_swap_32 (pdf
->o_buf
[6]),
7530 byte_swap_32 (pdf
->o_buf
[7])
7533 else if (hash_mode
== 10420)
7535 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7537 pdf_t
*pdf
= &pdfs
[salt_pos
];
7539 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7541 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",
7549 byte_swap_32 (pdf
->id_buf
[0]),
7550 byte_swap_32 (pdf
->id_buf
[1]),
7551 byte_swap_32 (pdf
->id_buf
[2]),
7552 byte_swap_32 (pdf
->id_buf
[3]),
7554 byte_swap_32 (pdf
->u_buf
[0]),
7555 byte_swap_32 (pdf
->u_buf
[1]),
7556 byte_swap_32 (pdf
->u_buf
[2]),
7557 byte_swap_32 (pdf
->u_buf
[3]),
7558 byte_swap_32 (pdf
->u_buf
[4]),
7559 byte_swap_32 (pdf
->u_buf
[5]),
7560 byte_swap_32 (pdf
->u_buf
[6]),
7561 byte_swap_32 (pdf
->u_buf
[7]),
7563 byte_swap_32 (pdf
->o_buf
[0]),
7564 byte_swap_32 (pdf
->o_buf
[1]),
7565 byte_swap_32 (pdf
->o_buf
[2]),
7566 byte_swap_32 (pdf
->o_buf
[3]),
7567 byte_swap_32 (pdf
->o_buf
[4]),
7568 byte_swap_32 (pdf
->o_buf
[5]),
7569 byte_swap_32 (pdf
->o_buf
[6]),
7570 byte_swap_32 (pdf
->o_buf
[7]),
7578 else if (hash_mode
== 10500)
7580 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7582 pdf_t
*pdf
= &pdfs
[salt_pos
];
7584 if (pdf
->id_len
== 32)
7586 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",
7594 byte_swap_32 (pdf
->id_buf
[0]),
7595 byte_swap_32 (pdf
->id_buf
[1]),
7596 byte_swap_32 (pdf
->id_buf
[2]),
7597 byte_swap_32 (pdf
->id_buf
[3]),
7598 byte_swap_32 (pdf
->id_buf
[4]),
7599 byte_swap_32 (pdf
->id_buf
[5]),
7600 byte_swap_32 (pdf
->id_buf
[6]),
7601 byte_swap_32 (pdf
->id_buf
[7]),
7603 byte_swap_32 (pdf
->u_buf
[0]),
7604 byte_swap_32 (pdf
->u_buf
[1]),
7605 byte_swap_32 (pdf
->u_buf
[2]),
7606 byte_swap_32 (pdf
->u_buf
[3]),
7607 byte_swap_32 (pdf
->u_buf
[4]),
7608 byte_swap_32 (pdf
->u_buf
[5]),
7609 byte_swap_32 (pdf
->u_buf
[6]),
7610 byte_swap_32 (pdf
->u_buf
[7]),
7612 byte_swap_32 (pdf
->o_buf
[0]),
7613 byte_swap_32 (pdf
->o_buf
[1]),
7614 byte_swap_32 (pdf
->o_buf
[2]),
7615 byte_swap_32 (pdf
->o_buf
[3]),
7616 byte_swap_32 (pdf
->o_buf
[4]),
7617 byte_swap_32 (pdf
->o_buf
[5]),
7618 byte_swap_32 (pdf
->o_buf
[6]),
7619 byte_swap_32 (pdf
->o_buf
[7])
7624 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",
7632 byte_swap_32 (pdf
->id_buf
[0]),
7633 byte_swap_32 (pdf
->id_buf
[1]),
7634 byte_swap_32 (pdf
->id_buf
[2]),
7635 byte_swap_32 (pdf
->id_buf
[3]),
7637 byte_swap_32 (pdf
->u_buf
[0]),
7638 byte_swap_32 (pdf
->u_buf
[1]),
7639 byte_swap_32 (pdf
->u_buf
[2]),
7640 byte_swap_32 (pdf
->u_buf
[3]),
7641 byte_swap_32 (pdf
->u_buf
[4]),
7642 byte_swap_32 (pdf
->u_buf
[5]),
7643 byte_swap_32 (pdf
->u_buf
[6]),
7644 byte_swap_32 (pdf
->u_buf
[7]),
7646 byte_swap_32 (pdf
->o_buf
[0]),
7647 byte_swap_32 (pdf
->o_buf
[1]),
7648 byte_swap_32 (pdf
->o_buf
[2]),
7649 byte_swap_32 (pdf
->o_buf
[3]),
7650 byte_swap_32 (pdf
->o_buf
[4]),
7651 byte_swap_32 (pdf
->o_buf
[5]),
7652 byte_swap_32 (pdf
->o_buf
[6]),
7653 byte_swap_32 (pdf
->o_buf
[7])
7657 else if (hash_mode
== 10600)
7659 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7661 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7662 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7664 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7666 else if (hash_mode
== 10700)
7668 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7670 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7671 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7673 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7675 else if (hash_mode
== 10900)
7677 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7679 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7680 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7682 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7684 else if (hash_mode
== 11100)
7686 uint32_t salt_challenge
= salt
.salt_buf
[0];
7688 salt_challenge
= byte_swap_32 (salt_challenge
);
7690 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7692 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7693 SIGNATURE_POSTGRESQL_AUTH
,
7701 else if (hash_mode
== 11200)
7703 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7704 SIGNATURE_MYSQL_AUTH
,
7705 (unsigned char *) salt
.salt_buf
,
7712 else if (hash_mode
== 11300)
7714 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7716 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7718 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7719 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7720 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7722 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7723 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7724 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7726 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7728 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7730 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7733 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7735 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7737 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7740 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7742 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7744 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7747 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7748 SIGNATURE_BITCOIN_WALLET
,
7752 (unsigned char *) salt
.salt_buf
,
7760 free (cry_master_buf
);
7762 free (public_key_buf
);
7764 else if (hash_mode
== 11400)
7766 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7768 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7769 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7771 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7773 else if (hash_mode
== 11600)
7775 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7777 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7779 const uint data_len
= seven_zip
->data_len
;
7781 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7783 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7785 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7787 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7790 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7791 SIGNATURE_SEVEN_ZIP
,
7795 (char *) seven_zip
->salt_buf
,
7797 seven_zip
->iv_buf
[0],
7798 seven_zip
->iv_buf
[1],
7799 seven_zip
->iv_buf
[2],
7800 seven_zip
->iv_buf
[3],
7802 seven_zip
->data_len
,
7803 seven_zip
->unpack_size
,
7808 else if (hash_mode
== 11700)
7810 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7820 else if (hash_mode
== 11800)
7822 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7840 else if (hash_mode
== 11900)
7842 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7844 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7845 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7847 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7849 else if (hash_mode
== 12000)
7851 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7853 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7854 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7856 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7858 else if (hash_mode
== 12100)
7860 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7862 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7863 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7865 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7867 else if (hash_mode
== 12200)
7869 uint
*ptr_digest
= digest_buf
;
7870 uint
*ptr_salt
= salt
.salt_buf
;
7872 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7879 else if (hash_mode
== 12300)
7881 uint
*ptr_digest
= digest_buf
;
7882 uint
*ptr_salt
= salt
.salt_buf
;
7884 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",
7885 ptr_digest
[ 0], ptr_digest
[ 1],
7886 ptr_digest
[ 2], ptr_digest
[ 3],
7887 ptr_digest
[ 4], ptr_digest
[ 5],
7888 ptr_digest
[ 6], ptr_digest
[ 7],
7889 ptr_digest
[ 8], ptr_digest
[ 9],
7890 ptr_digest
[10], ptr_digest
[11],
7891 ptr_digest
[12], ptr_digest
[13],
7892 ptr_digest
[14], ptr_digest
[15],
7898 else if (hash_mode
== 12400)
7900 // encode iteration count
7904 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7905 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7906 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7907 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7912 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7913 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7914 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7915 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7920 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7922 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7923 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7925 memcpy (tmp_buf
, digest_buf
, 8);
7927 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7931 // fill the resulting buffer
7933 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7935 else if (hash_mode
== 12500)
7937 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7939 byte_swap_32 (salt
.salt_buf
[0]),
7940 byte_swap_32 (salt
.salt_buf
[1]),
7946 else if (hash_mode
== 12600)
7948 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7949 digest_buf
[0] + salt
.salt_buf_pc
[0],
7950 digest_buf
[1] + salt
.salt_buf_pc
[1],
7951 digest_buf
[2] + salt
.salt_buf_pc
[2],
7952 digest_buf
[3] + salt
.salt_buf_pc
[3],
7953 digest_buf
[4] + salt
.salt_buf_pc
[4],
7954 digest_buf
[5] + salt
.salt_buf_pc
[5],
7955 digest_buf
[6] + salt
.salt_buf_pc
[6],
7956 digest_buf
[7] + salt
.salt_buf_pc
[7]);
7958 else if (hash_mode
== 12700)
7960 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7962 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7963 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7965 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7967 else if (hash_mode
== 12800)
7969 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
7971 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",
7984 byte_swap_32 (digest_buf
[0]),
7985 byte_swap_32 (digest_buf
[1]),
7986 byte_swap_32 (digest_buf
[2]),
7987 byte_swap_32 (digest_buf
[3]),
7988 byte_swap_32 (digest_buf
[4]),
7989 byte_swap_32 (digest_buf
[5]),
7990 byte_swap_32 (digest_buf
[6]),
7991 byte_swap_32 (digest_buf
[7])
7996 if (hash_type
== HASH_TYPE_MD4
)
7998 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8004 else if (hash_type
== HASH_TYPE_MD5
)
8006 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8012 else if (hash_type
== HASH_TYPE_SHA1
)
8014 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8021 else if (hash_type
== HASH_TYPE_SHA256
)
8023 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8033 else if (hash_type
== HASH_TYPE_SHA384
)
8035 uint
*ptr
= digest_buf
;
8037 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8045 else if (hash_type
== HASH_TYPE_SHA512
)
8047 uint
*ptr
= digest_buf
;
8049 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8059 else if (hash_type
== HASH_TYPE_LM
)
8061 snprintf (out_buf
, len
-1, "%08x%08x",
8065 else if (hash_type
== HASH_TYPE_ORACLEH
)
8067 snprintf (out_buf
, len
-1, "%08X%08X",
8071 else if (hash_type
== HASH_TYPE_BCRYPT
)
8073 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8074 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8076 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8078 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8080 else if (hash_type
== HASH_TYPE_KECCAK
)
8082 uint
*ptr
= digest_buf
;
8084 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",
8112 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8114 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8116 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8123 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8125 digest_buf
[ 0] = digest_buf
[ 0];
8126 digest_buf
[ 1] = digest_buf
[ 1];
8127 digest_buf
[ 2] = digest_buf
[ 2];
8128 digest_buf
[ 3] = digest_buf
[ 3];
8129 digest_buf
[ 4] = digest_buf
[ 4];
8130 digest_buf
[ 5] = digest_buf
[ 5];
8131 digest_buf
[ 6] = digest_buf
[ 6];
8132 digest_buf
[ 7] = digest_buf
[ 7];
8133 digest_buf
[ 8] = digest_buf
[ 8];
8134 digest_buf
[ 9] = digest_buf
[ 9];
8135 digest_buf
[10] = digest_buf
[10];
8136 digest_buf
[11] = digest_buf
[11];
8137 digest_buf
[12] = digest_buf
[12];
8138 digest_buf
[13] = digest_buf
[13];
8139 digest_buf
[14] = digest_buf
[14];
8140 digest_buf
[15] = digest_buf
[15];
8142 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8160 else if (hash_type
== HASH_TYPE_GOST
)
8162 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8172 else if (hash_type
== HASH_TYPE_MYSQL
)
8174 snprintf (out_buf
, len
-1, "%08x%08x",
8178 else if (hash_type
== HASH_TYPE_LOTUS5
)
8180 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8186 else if (hash_type
== HASH_TYPE_LOTUS6
)
8188 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8189 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8190 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8191 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8195 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8196 memcpy (buf
+ 5, digest_buf
, 9);
8200 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8202 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8205 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8207 else if (hash_type
== HASH_TYPE_LOTUS8
)
8211 memset (buf
, 0, sizeof (buf
));
8215 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8221 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8225 buf
[26] = salt
.salt_buf_pc
[0];
8226 buf
[27] = salt
.salt_buf_pc
[1];
8230 memcpy (buf
+ 28, digest_buf
, 8);
8232 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8236 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8238 else if (hash_type
== HASH_TYPE_CRC32
)
8240 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8244 if (salt_type
== SALT_TYPE_INTERN
)
8246 size_t pos
= strlen (out_buf
);
8248 out_buf
[pos
] = data
.separator
;
8250 char *ptr
= (char *) salt
.salt_buf
;
8252 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8254 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8258 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8260 memset (hccap
, 0, sizeof (hccap_t
));
8262 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8264 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8266 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8267 wpa_t
*wpa
= &wpas
[salt_pos
];
8269 hccap
->keyver
= wpa
->keyver
;
8271 hccap
->eapol_size
= wpa
->eapol_size
;
8273 if (wpa
->keyver
!= 1)
8277 for (uint i
= 0; i
< 64; i
++)
8279 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8282 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8286 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8291 for (int i
= 5; i
< 25; i
++)
8293 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8296 char *pke_ptr
= (char *) pke_tmp
;
8298 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8299 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8300 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8301 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8303 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8305 uint dgst_size
= data
.dgst_size
;
8307 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8309 if (wpa
->keyver
!= 1)
8313 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8314 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8315 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8316 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8318 memcpy (hccap
->keymic
, digest_tmp
, 16);
8322 memcpy (hccap
->keymic
, digest_ptr
, 16);
8326 void SuspendThreads ()
8328 if (data
.devices_status
== STATUS_RUNNING
)
8330 hc_timer_set (&data
.timer_paused
);
8332 data
.devices_status
= STATUS_PAUSED
;
8334 log_info ("Paused");
8338 void ResumeThreads ()
8340 if (data
.devices_status
== STATUS_PAUSED
)
8344 hc_timer_get (data
.timer_paused
, ms_paused
);
8346 data
.ms_paused
+= ms_paused
;
8348 data
.devices_status
= STATUS_RUNNING
;
8350 log_info ("Resumed");
8356 if (data
.devices_status
!= STATUS_RUNNING
) return;
8358 data
.devices_status
= STATUS_BYPASS
;
8360 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8365 if (data
.devices_status
== STATUS_INIT
) return;
8366 if (data
.devices_status
== STATUS_STARTING
) return;
8368 data
.devices_status
= STATUS_ABORTED
;
8373 if (data
.devices_status
== STATUS_INIT
) return;
8374 if (data
.devices_status
== STATUS_STARTING
) return;
8376 data
.devices_status
= STATUS_QUIT
;
8380 uint
get_vliw_by_device_name (const char *device_name
)
8384 if (strcmp (device_name
, "Capeverde" ) == 0) vliw
= 1;
8385 if (strcmp (device_name
, "Pitcairn" ) == 0) vliw
= 1;
8386 if (strcmp (device_name
, "Tahiti" ) == 0) vliw
= 1;
8387 if (strcmp (device_name
, "ATI RV710" ) == 0) vliw
= 1;
8388 if (strcmp (device_name
, "ATI RV730" ) == 0) vliw
= 1;
8389 if (strcmp (device_name
, "ATI RV770" ) == 0) vliw
= 4;
8390 if (strcmp (device_name
, "Cayman" ) == 0) vliw
= 4;
8391 if (strcmp (device_name
, "Devastator" ) == 0) vliw
= 4;
8392 if (strcmp (device_name
, "Scrapper" ) == 0) vliw
= 4;
8393 if (strcmp (device_name
, "Barts" ) == 0) vliw
= 5;
8394 if (strcmp (device_name
, "BeaverCreek" ) == 0) vliw
= 5;
8395 if (strcmp (device_name
, "Caicos" ) == 0) vliw
= 5;
8396 if (strcmp (device_name
, "Cedar" ) == 0) vliw
= 5;
8397 if (strcmp (device_name
, "Cypress" ) == 0) vliw
= 5;
8398 if (strcmp (device_name
, "Juniper" ) == 0) vliw
= 5;
8399 if (strcmp (device_name
, "Loveland" ) == 0) vliw
= 5;
8400 if (strcmp (device_name
, "Redwood" ) == 0) vliw
= 5;
8401 if (strcmp (device_name
, "Turks" ) == 0) vliw
= 5;
8402 if (strcmp (device_name
, "WinterPark" ) == 0) vliw
= 5;
8403 if (strcmp (device_name
, "Oland" ) == 0) vliw
= 1;
8404 if (strcmp (device_name
, "Cats" ) == 0) vliw
= 1;
8405 if (strcmp (device_name
, "Raccoons" ) == 0) vliw
= 1;
8406 if (strcmp (device_name
, "Bonaire" ) == 0) vliw
= 1;
8407 if (strcmp (device_name
, "Hawaii" ) == 0) vliw
= 1;
8408 if (strcmp (device_name
, "Spectre" ) == 0) vliw
= 1;
8409 if (strcmp (device_name
, "Spooky" ) == 0) vliw
= 1;
8410 if (strcmp (device_name
, "Kalindi" ) == 0) vliw
= 1;
8411 if (strcmp (device_name
, "Hainan" ) == 0) vliw
= 1;
8412 if (strcmp (device_name
, "Iceland" ) == 0) vliw
= 1;
8413 if (strcmp (device_name
, "Tonga" ) == 0) vliw
= 1;
8414 if (strcmp (device_name
, "Mullins" ) == 0) vliw
= 1;
8415 if (strcmp (device_name
, "Fiji" ) == 0) vliw
= 1;
8417 if (strncmp (device_name
, "ATI Radeon HD 4", 15) == 0) vliw
= 1;
8418 if (strncmp (device_name
, "ATI Radeon HD 5", 15) == 0) vliw
= 5;
8419 if (strncmp (device_name
, "ATI Radeon HD 6", 15) == 0) vliw
= 4;
8420 if (strncmp (device_name
, "ATI Radeon HD 7", 15) == 0) vliw
= 4;
8421 if (strncmp (device_name
, "ATI Radeon HD 79", 16) == 0) vliw
= 1;
8422 if (strncmp (device_name
, "ATI Radeon HD 8", 15) == 0) vliw
= 1;
8423 if (strncmp (device_name
, "AMD Radeon R9", 13) == 0) vliw
= 1;
8428 uint
get_vliw_by_compute_capability (const uint major
, const uint minor
)
8432 if (major
== 1 && minor
== 0) vliw
= 1;
8433 if (major
== 1 && minor
== 1) vliw
= 1;
8434 if (major
== 1 && minor
== 2) vliw
= 1;
8435 if (major
== 1 && minor
== 3) vliw
= 1;
8436 if (major
== 2 && minor
== 0) vliw
= 1;
8437 if (major
== 2 && minor
== 1) vliw
= 2;
8438 if (major
== 3 && minor
== 0) vliw
= 2;
8439 if (major
== 3 && minor
== 5) vliw
= 2;
8440 if (major
== 3 && minor
== 7) vliw
= 2;
8441 if (major
== 5 && minor
== 0) vliw
= 2;
8442 if (major
== 5 && minor
== 2) vliw
= 2;
8449 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8453 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8457 memset (&st
, 0, sizeof (st
));
8459 stat (kernel_file
, &st
);
8461 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8463 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8465 if (num_read
!= (size_t) st
.st_size
)
8467 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8474 buf
[st
.st_size
] = 0;
8476 for (int i
= 0; i
< num_devices
; i
++)
8478 kernel_lengths
[i
] = (size_t) st
.st_size
;
8480 kernel_sources
[i
] = buf
;
8485 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8493 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8495 FILE *fp
= fopen (dst
, "wb");
8497 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8508 restore_data_t
*init_restore (int argc
, char **argv
)
8510 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8512 if (data
.restore_disable
== 0)
8514 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8518 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8522 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8531 char pidbin
[BUFSIZ
];
8536 memset (pidbin
, 0, sizeof (pidbin
));
8538 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8540 FILE *fd
= fopen (pidbin
, "rb");
8544 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8546 pidbin
[pidbin_len
] = 0;
8550 char *argv0_r
= strrchr (argv
[0], '/');
8552 char *pidbin_r
= strrchr (pidbin
, '/');
8554 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8556 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8558 if (strcmp (argv0_r
, pidbin_r
) == 0)
8560 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8567 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8569 char pidbin2
[BUFSIZ
];
8573 memset (pidbin2
, 0, sizeof (pidbin2
));
8575 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8576 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8578 pidbin
[pidbin_len
] = 0;
8579 pidbin2
[pidbin2_len
] = 0;
8583 if (strcmp (pidbin
, pidbin2
) == 0)
8585 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8593 if (rd
->version_bin
< RESTORE_MIN
)
8595 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8602 memset (rd
, 0, sizeof (restore_data_t
));
8604 rd
->version_bin
= VERSION_BIN
;
8607 rd
->pid
= getpid ();
8609 rd
->pid
= GetCurrentProcessId ();
8612 if (getcwd (rd
->cwd
, 255) == NULL
)
8625 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8627 FILE *fp
= fopen (eff_restore_file
, "rb");
8631 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8636 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8638 log_error ("ERROR: cannot read %s", eff_restore_file
);
8643 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8645 for (uint i
= 0; i
< rd
->argc
; i
++)
8649 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8651 log_error ("ERROR: cannot read %s", eff_restore_file
);
8656 size_t len
= strlen (buf
);
8658 if (len
) buf
[len
- 1] = 0;
8660 rd
->argv
[i
] = mystrdup (buf
);
8667 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8671 log_error ("Restore file is corrupted");
8674 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8676 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8678 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8683 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8687 if (chdir (rd
->cwd
))
8689 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8695 uint64_t get_lowest_words_done ()
8697 uint64_t words_cur
= -1;
8699 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8701 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8703 const uint64_t words_done
= device_param
->words_done
;
8705 if (words_done
< words_cur
) words_cur
= words_done
;
8711 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8713 uint64_t words_cur
= get_lowest_words_done ();
8715 rd
->words_cur
= words_cur
;
8717 FILE *fp
= fopen (new_restore_file
, "wb");
8721 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8726 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8728 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8733 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8735 for (uint i
= 0; i
< rd
->argc
; i
++)
8737 fprintf (fp
, "%s", rd
->argv
[i
]);
8743 fsync (fileno (fp
));
8748 void cycle_restore ()
8750 const char *eff_restore_file
= data
.eff_restore_file
;
8751 const char *new_restore_file
= data
.new_restore_file
;
8753 restore_data_t
*rd
= data
.rd
;
8755 write_restore (new_restore_file
, rd
);
8759 memset (&st
, 0, sizeof(st
));
8761 if (stat (eff_restore_file
, &st
) == 0)
8763 if (unlink (eff_restore_file
))
8765 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8769 if (rename (new_restore_file
, eff_restore_file
))
8771 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8779 uint
set_gpu_accel (uint hash_mode
)
8783 case 0: return GET_ACCEL (0);
8784 case 10: return GET_ACCEL (10);
8785 case 11: return GET_ACCEL (11);
8786 case 12: return GET_ACCEL (12);
8787 case 20: return GET_ACCEL (20);
8788 case 21: return GET_ACCEL (21);
8789 case 22: return GET_ACCEL (22);
8790 case 23: return GET_ACCEL (23);
8791 case 30: return GET_ACCEL (30);
8792 case 40: return GET_ACCEL (40);
8793 case 50: return GET_ACCEL (50);
8794 case 60: return GET_ACCEL (60);
8795 case 100: return GET_ACCEL (100);
8796 case 101: return GET_ACCEL (101);
8797 case 110: return GET_ACCEL (110);
8798 case 111: return GET_ACCEL (111);
8799 case 112: return GET_ACCEL (112);
8800 case 120: return GET_ACCEL (120);
8801 case 121: return GET_ACCEL (121);
8802 case 122: return GET_ACCEL (122);
8803 case 124: return GET_ACCEL (124);
8804 case 130: return GET_ACCEL (130);
8805 case 131: return GET_ACCEL (131);
8806 case 132: return GET_ACCEL (132);
8807 case 133: return GET_ACCEL (133);
8808 case 140: return GET_ACCEL (140);
8809 case 141: return GET_ACCEL (141);
8810 case 150: return GET_ACCEL (150);
8811 case 160: return GET_ACCEL (160);
8812 case 190: return GET_ACCEL (190);
8813 case 200: return GET_ACCEL (200);
8814 case 300: return GET_ACCEL (300);
8815 case 400: return GET_ACCEL (400);
8816 case 500: return GET_ACCEL (500);
8817 case 501: return GET_ACCEL (501);
8818 case 900: return GET_ACCEL (900);
8819 case 910: return GET_ACCEL (910);
8820 case 1000: return GET_ACCEL (1000);
8821 case 1100: return GET_ACCEL (1100);
8822 case 1400: return GET_ACCEL (1400);
8823 case 1410: return GET_ACCEL (1410);
8824 case 1420: return GET_ACCEL (1420);
8825 case 1421: return GET_ACCEL (1421);
8826 case 1430: return GET_ACCEL (1430);
8827 case 1440: return GET_ACCEL (1440);
8828 case 1441: return GET_ACCEL (1441);
8829 case 1450: return GET_ACCEL (1450);
8830 case 1460: return GET_ACCEL (1460);
8831 case 1500: return GET_ACCEL (1500);
8832 case 1600: return GET_ACCEL (1600);
8833 case 1700: return GET_ACCEL (1700);
8834 case 1710: return GET_ACCEL (1710);
8835 case 1711: return GET_ACCEL (1711);
8836 case 1720: return GET_ACCEL (1720);
8837 case 1722: return GET_ACCEL (1722);
8838 case 1730: return GET_ACCEL (1730);
8839 case 1731: return GET_ACCEL (1731);
8840 case 1740: return GET_ACCEL (1740);
8841 case 1750: return GET_ACCEL (1750);
8842 case 1760: return GET_ACCEL (1760);
8843 case 1800: return GET_ACCEL (1800);
8844 case 2100: return GET_ACCEL (2100);
8845 case 2400: return GET_ACCEL (2400);
8846 case 2410: return GET_ACCEL (2410);
8847 case 2500: return GET_ACCEL (2500);
8848 case 2600: return GET_ACCEL (2600);
8849 case 2611: return GET_ACCEL (2611);
8850 case 2612: return GET_ACCEL (2612);
8851 case 2711: return GET_ACCEL (2711);
8852 case 2811: return GET_ACCEL (2811);
8853 case 3000: return GET_ACCEL (3000);
8854 case 3100: return GET_ACCEL (3100);
8855 case 3200: return GET_ACCEL (3200);
8856 case 3710: return GET_ACCEL (3710);
8857 case 3711: return GET_ACCEL (3711);
8858 case 3800: return GET_ACCEL (3800);
8859 case 4300: return GET_ACCEL (4300);
8860 case 4400: return GET_ACCEL (4400);
8861 case 4500: return GET_ACCEL (4500);
8862 case 4700: return GET_ACCEL (4700);
8863 case 4800: return GET_ACCEL (4800);
8864 case 4900: return GET_ACCEL (4900);
8865 case 5000: return GET_ACCEL (5000);
8866 case 5100: return GET_ACCEL (5100);
8867 case 5200: return GET_ACCEL (5200);
8868 case 5300: return GET_ACCEL (5300);
8869 case 5400: return GET_ACCEL (5400);
8870 case 5500: return GET_ACCEL (5500);
8871 case 5600: return GET_ACCEL (5600);
8872 case 5700: return GET_ACCEL (5700);
8873 case 5800: return GET_ACCEL (5800);
8874 case 6000: return GET_ACCEL (6000);
8875 case 6100: return GET_ACCEL (6100);
8876 case 6211: return GET_ACCEL (6211);
8877 case 6212: return GET_ACCEL (6212);
8878 case 6213: return GET_ACCEL (6213);
8879 case 6221: return GET_ACCEL (6221);
8880 case 6222: return GET_ACCEL (6222);
8881 case 6223: return GET_ACCEL (6223);
8882 case 6231: return GET_ACCEL (6231);
8883 case 6232: return GET_ACCEL (6232);
8884 case 6233: return GET_ACCEL (6233);
8885 case 6241: return GET_ACCEL (6241);
8886 case 6242: return GET_ACCEL (6242);
8887 case 6243: return GET_ACCEL (6243);
8888 case 6300: return GET_ACCEL (6300);
8889 case 6400: return GET_ACCEL (6400);
8890 case 6500: return GET_ACCEL (6500);
8891 case 6600: return GET_ACCEL (6600);
8892 case 6700: return GET_ACCEL (6700);
8893 case 6800: return GET_ACCEL (6800);
8894 case 6900: return GET_ACCEL (6900);
8895 case 7100: return GET_ACCEL (7100);
8896 case 7200: return GET_ACCEL (7200);
8897 case 7300: return GET_ACCEL (7300);
8898 case 7400: return GET_ACCEL (7400);
8899 case 7500: return GET_ACCEL (7500);
8900 case 7600: return GET_ACCEL (7600);
8901 case 7700: return GET_ACCEL (7700);
8902 case 7800: return GET_ACCEL (7800);
8903 case 7900: return GET_ACCEL (7900);
8904 case 8000: return GET_ACCEL (8000);
8905 case 8100: return GET_ACCEL (8100);
8906 case 8200: return GET_ACCEL (8200);
8907 case 8300: return GET_ACCEL (8300);
8908 case 8400: return GET_ACCEL (8400);
8909 case 8500: return GET_ACCEL (8500);
8910 case 8600: return GET_ACCEL (8600);
8911 case 8700: return GET_ACCEL (8700);
8912 case 8800: return GET_ACCEL (8800);
8913 case 8900: return GET_ACCEL (8900);
8914 case 9000: return GET_ACCEL (9000);
8915 case 9100: return GET_ACCEL (9100);
8916 case 9200: return GET_ACCEL (9200);
8917 case 9300: return GET_ACCEL (9300);
8918 case 9400: return GET_ACCEL (9400);
8919 case 9500: return GET_ACCEL (9500);
8920 case 9600: return GET_ACCEL (9600);
8921 case 9700: return GET_ACCEL (9700);
8922 case 9710: return GET_ACCEL (9710);
8923 case 9720: return GET_ACCEL (9720);
8924 case 9800: return GET_ACCEL (9800);
8925 case 9810: return GET_ACCEL (9810);
8926 case 9820: return GET_ACCEL (9820);
8927 case 9900: return GET_ACCEL (9900);
8928 case 10000: return GET_ACCEL (10000);
8929 case 10100: return GET_ACCEL (10100);
8930 case 10200: return GET_ACCEL (10200);
8931 case 10300: return GET_ACCEL (10300);
8932 case 10400: return GET_ACCEL (10400);
8933 case 10410: return GET_ACCEL (10410);
8934 case 10420: return GET_ACCEL (10420);
8935 case 10500: return GET_ACCEL (10500);
8936 case 10600: return GET_ACCEL (10600);
8937 case 10700: return GET_ACCEL (10700);
8938 case 10800: return GET_ACCEL (10800);
8939 case 10900: return GET_ACCEL (10900);
8940 case 11000: return GET_ACCEL (11000);
8941 case 11100: return GET_ACCEL (11100);
8942 case 11200: return GET_ACCEL (11200);
8943 case 11300: return GET_ACCEL (11300);
8944 case 11400: return GET_ACCEL (11400);
8945 case 11500: return GET_ACCEL (11500);
8946 case 11600: return GET_ACCEL (11600);
8947 case 11700: return GET_ACCEL (11700);
8948 case 11800: return GET_ACCEL (11800);
8949 case 11900: return GET_ACCEL (11900);
8950 case 12000: return GET_ACCEL (12000);
8951 case 12100: return GET_ACCEL (12100);
8952 case 12200: return GET_ACCEL (12200);
8953 case 12300: return GET_ACCEL (12300);
8954 case 12400: return GET_ACCEL (12400);
8955 case 12500: return GET_ACCEL (12500);
8956 case 12600: return GET_ACCEL (12600);
8957 case 12700: return GET_ACCEL (12700);
8958 case 12800: return GET_ACCEL (12800);
8964 uint
set_gpu_loops (uint hash_mode
)
8968 case 0: return GET_LOOPS (0);
8969 case 10: return GET_LOOPS (10);
8970 case 11: return GET_LOOPS (11);
8971 case 12: return GET_LOOPS (12);
8972 case 20: return GET_LOOPS (20);
8973 case 21: return GET_LOOPS (21);
8974 case 22: return GET_LOOPS (22);
8975 case 23: return GET_LOOPS (23);
8976 case 30: return GET_LOOPS (30);
8977 case 40: return GET_LOOPS (40);
8978 case 50: return GET_LOOPS (50);
8979 case 60: return GET_LOOPS (60);
8980 case 100: return GET_LOOPS (100);
8981 case 101: return GET_LOOPS (101);
8982 case 110: return GET_LOOPS (110);
8983 case 111: return GET_LOOPS (111);
8984 case 112: return GET_LOOPS (112);
8985 case 120: return GET_LOOPS (120);
8986 case 121: return GET_LOOPS (121);
8987 case 122: return GET_LOOPS (122);
8988 case 124: return GET_LOOPS (124);
8989 case 130: return GET_LOOPS (130);
8990 case 131: return GET_LOOPS (131);
8991 case 132: return GET_LOOPS (132);
8992 case 133: return GET_LOOPS (133);
8993 case 140: return GET_LOOPS (140);
8994 case 141: return GET_LOOPS (141);
8995 case 150: return GET_LOOPS (150);
8996 case 160: return GET_LOOPS (160);
8997 case 190: return GET_LOOPS (190);
8998 case 200: return GET_LOOPS (200);
8999 case 300: return GET_LOOPS (300);
9000 case 400: return GET_LOOPS (400);
9001 case 500: return GET_LOOPS (500);
9002 case 501: return GET_LOOPS (501);
9003 case 900: return GET_LOOPS (900);
9004 case 910: return GET_LOOPS (910);
9005 case 1000: return GET_LOOPS (1000);
9006 case 1100: return GET_LOOPS (1100);
9007 case 1400: return GET_LOOPS (1400);
9008 case 1410: return GET_LOOPS (1410);
9009 case 1420: return GET_LOOPS (1420);
9010 case 1421: return GET_LOOPS (1421);
9011 case 1430: return GET_LOOPS (1430);
9012 case 1440: return GET_LOOPS (1440);
9013 case 1441: return GET_LOOPS (1441);
9014 case 1450: return GET_LOOPS (1450);
9015 case 1460: return GET_LOOPS (1460);
9016 case 1500: return GET_LOOPS (1500);
9017 case 1600: return GET_LOOPS (1600);
9018 case 1700: return GET_LOOPS (1700);
9019 case 1710: return GET_LOOPS (1710);
9020 case 1711: return GET_LOOPS (1711);
9021 case 1720: return GET_LOOPS (1720);
9022 case 1722: return GET_LOOPS (1722);
9023 case 1730: return GET_LOOPS (1730);
9024 case 1731: return GET_LOOPS (1731);
9025 case 1740: return GET_LOOPS (1740);
9026 case 1750: return GET_LOOPS (1750);
9027 case 1760: return GET_LOOPS (1760);
9028 case 1800: return GET_LOOPS (1800);
9029 case 2100: return GET_LOOPS (2100);
9030 case 2400: return GET_LOOPS (2400);
9031 case 2410: return GET_LOOPS (2410);
9032 case 2500: return GET_LOOPS (2500);
9033 case 2600: return GET_LOOPS (2600);
9034 case 2611: return GET_LOOPS (2611);
9035 case 2612: return GET_LOOPS (2612);
9036 case 2711: return GET_LOOPS (2711);
9037 case 2811: return GET_LOOPS (2811);
9038 case 3000: return GET_LOOPS (3000);
9039 case 3100: return GET_LOOPS (3100);
9040 case 3200: return GET_LOOPS (3200);
9041 case 3710: return GET_LOOPS (3710);
9042 case 3711: return GET_LOOPS (3711);
9043 case 3800: return GET_LOOPS (3800);
9044 case 4300: return GET_LOOPS (4300);
9045 case 4400: return GET_LOOPS (4400);
9046 case 4500: return GET_LOOPS (4500);
9047 case 4700: return GET_LOOPS (4700);
9048 case 4800: return GET_LOOPS (4800);
9049 case 4900: return GET_LOOPS (4900);
9050 case 5000: return GET_LOOPS (5000);
9051 case 5100: return GET_LOOPS (5100);
9052 case 5200: return GET_LOOPS (5200);
9053 case 5300: return GET_LOOPS (5300);
9054 case 5400: return GET_LOOPS (5400);
9055 case 5500: return GET_LOOPS (5500);
9056 case 5600: return GET_LOOPS (5600);
9057 case 5700: return GET_LOOPS (5700);
9058 case 5800: return GET_LOOPS (5800);
9059 case 6000: return GET_LOOPS (6000);
9060 case 6100: return GET_LOOPS (6100);
9061 case 6211: return GET_LOOPS (6211);
9062 case 6212: return GET_LOOPS (6212);
9063 case 6213: return GET_LOOPS (6213);
9064 case 6221: return GET_LOOPS (6221);
9065 case 6222: return GET_LOOPS (6222);
9066 case 6223: return GET_LOOPS (6223);
9067 case 6231: return GET_LOOPS (6231);
9068 case 6232: return GET_LOOPS (6232);
9069 case 6233: return GET_LOOPS (6233);
9070 case 6241: return GET_LOOPS (6241);
9071 case 6242: return GET_LOOPS (6242);
9072 case 6243: return GET_LOOPS (6243);
9073 case 6300: return GET_LOOPS (6300);
9074 case 6400: return GET_LOOPS (6400);
9075 case 6500: return GET_LOOPS (6500);
9076 case 6600: return GET_LOOPS (6600);
9077 case 6700: return GET_LOOPS (6700);
9078 case 6800: return GET_LOOPS (6800);
9079 case 6900: return GET_LOOPS (6900);
9080 case 7100: return GET_LOOPS (7100);
9081 case 7200: return GET_LOOPS (7200);
9082 case 7300: return GET_LOOPS (7300);
9083 case 7400: return GET_LOOPS (7400);
9084 case 7500: return GET_LOOPS (7500);
9085 case 7600: return GET_LOOPS (7600);
9086 case 7700: return GET_LOOPS (7700);
9087 case 7800: return GET_LOOPS (7800);
9088 case 7900: return GET_LOOPS (7900);
9089 case 8000: return GET_LOOPS (8000);
9090 case 8100: return GET_LOOPS (8100);
9091 case 8200: return GET_LOOPS (8200);
9092 case 8300: return GET_LOOPS (8300);
9093 case 8400: return GET_LOOPS (8400);
9094 case 8500: return GET_LOOPS (8500);
9095 case 8600: return GET_LOOPS (8600);
9096 case 8700: return GET_LOOPS (8700);
9097 case 8800: return GET_LOOPS (8800);
9098 case 8900: return GET_LOOPS (8900);
9099 case 9000: return GET_LOOPS (9000);
9100 case 9100: return GET_LOOPS (9100);
9101 case 9200: return GET_LOOPS (9200);
9102 case 9300: return GET_LOOPS (9300);
9103 case 9400: return GET_LOOPS (9400);
9104 case 9500: return GET_LOOPS (9500);
9105 case 9600: return GET_LOOPS (9600);
9106 case 9700: return GET_LOOPS (9700);
9107 case 9710: return GET_LOOPS (9710);
9108 case 9720: return GET_LOOPS (9720);
9109 case 9800: return GET_LOOPS (9800);
9110 case 9810: return GET_LOOPS (9810);
9111 case 9820: return GET_LOOPS (9820);
9112 case 9900: return GET_LOOPS (9900);
9113 case 10000: return GET_LOOPS (10000);
9114 case 10100: return GET_LOOPS (10100);
9115 case 10200: return GET_LOOPS (10200);
9116 case 10300: return GET_LOOPS (10300);
9117 case 10400: return GET_LOOPS (10400);
9118 case 10410: return GET_LOOPS (10410);
9119 case 10420: return GET_LOOPS (10420);
9120 case 10500: return GET_LOOPS (10500);
9121 case 10600: return GET_LOOPS (10600);
9122 case 10700: return GET_LOOPS (10700);
9123 case 10800: return GET_LOOPS (10800);
9124 case 10900: return GET_LOOPS (10900);
9125 case 11000: return GET_LOOPS (11000);
9126 case 11100: return GET_LOOPS (11100);
9127 case 11200: return GET_LOOPS (11200);
9128 case 11300: return GET_LOOPS (11300);
9129 case 11400: return GET_LOOPS (11400);
9130 case 11500: return GET_LOOPS (11500);
9131 case 11600: return GET_LOOPS (11600);
9132 case 11700: return GET_LOOPS (11700);
9133 case 11800: return GET_LOOPS (11800);
9134 case 11900: return GET_LOOPS (11900);
9135 case 12000: return GET_LOOPS (12000);
9136 case 12100: return GET_LOOPS (12100);
9137 case 12200: return GET_LOOPS (12200);
9138 case 12300: return GET_LOOPS (12300);
9139 case 12400: return GET_LOOPS (12400);
9140 case 12500: return GET_LOOPS (12500);
9141 case 12600: return GET_LOOPS (12600);
9142 case 12700: return GET_LOOPS (12700);
9143 case 12800: return GET_LOOPS (12800);
9153 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9157 if (salt_len
> sizeof(tmp
))
9162 memset (tmp
, 0, sizeof (tmp
));
9163 memcpy (tmp
, in
, salt_len
);
9165 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9167 if ((salt_len
% 2) == 0)
9169 uint new_salt_len
= salt_len
/ 2;
9171 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9173 char p0
= tmp
[j
+ 0];
9174 char p1
= tmp
[j
+ 1];
9176 tmp
[i
] = hex_convert (p1
) << 0;
9177 tmp
[i
] |= hex_convert (p0
) << 4;
9180 salt_len
= new_salt_len
;
9187 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9189 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9192 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9194 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9198 uint
*tmp_uint
= (uint
*) tmp
;
9200 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9201 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9202 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9203 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9204 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9205 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9206 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9207 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9208 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9209 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9211 salt_len
= salt_len
* 2;
9219 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9221 lowercase (tmp
, salt_len
);
9224 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9226 uppercase (tmp
, salt_len
);
9229 uint len
= salt_len
;
9231 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9236 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9241 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9243 uint
*tmp_uint
= (uint
*) tmp
;
9249 for (uint i
= 0; i
< max
; i
++)
9251 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9254 // Important: we may need to increase the length of memcpy since
9255 // we don't want to "loose" some swapped bytes (could happen if
9256 // they do not perfectly fit in the 4-byte blocks)
9257 // Memcpy does always copy the bytes in the BE order, but since
9258 // we swapped them, some important bytes could be in positions
9259 // we normally skip with the original len
9261 if (len
% 4) len
+= 4 - (len
% 4);
9264 memcpy (out
, tmp
, len
);
9269 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9271 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9273 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9275 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9277 salt_t
*salt
= hash_buf
->salt
;
9279 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9281 char *iter_pos
= input_buf
+ 4;
9283 salt
->salt_iter
= 1 << atoi (iter_pos
);
9285 char *salt_pos
= strchr (iter_pos
, '$');
9287 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9293 salt
->salt_len
= salt_len
;
9297 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9299 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9301 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9303 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9305 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9306 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9307 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9308 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9310 char *hash_pos
= salt_pos
+ 22;
9312 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9314 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9316 memcpy (digest
, tmp_buf
, 24);
9318 digest
[0] = byte_swap_32 (digest
[0]);
9319 digest
[1] = byte_swap_32 (digest
[1]);
9320 digest
[2] = byte_swap_32 (digest
[2]);
9321 digest
[3] = byte_swap_32 (digest
[3]);
9322 digest
[4] = byte_swap_32 (digest
[4]);
9323 digest
[5] = byte_swap_32 (digest
[5]);
9325 digest
[5] &= ~0xff; // its just 23 not 24 !
9330 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9332 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9334 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9338 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9340 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9342 memcpy (digest
, tmp_buf
, 32);
9344 digest
[0] = byte_swap_32 (digest
[0]);
9345 digest
[1] = byte_swap_32 (digest
[1]);
9346 digest
[2] = byte_swap_32 (digest
[2]);
9347 digest
[3] = byte_swap_32 (digest
[3]);
9348 digest
[4] = byte_swap_32 (digest
[4]);
9349 digest
[5] = byte_swap_32 (digest
[5]);
9350 digest
[6] = byte_swap_32 (digest
[6]);
9351 digest
[7] = byte_swap_32 (digest
[7]);
9353 digest
[0] -= SHA256M_A
;
9354 digest
[1] -= SHA256M_B
;
9355 digest
[2] -= SHA256M_C
;
9356 digest
[3] -= SHA256M_D
;
9357 digest
[4] -= SHA256M_E
;
9358 digest
[5] -= SHA256M_F
;
9359 digest
[6] -= SHA256M_G
;
9360 digest
[7] -= SHA256M_H
;
9365 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9367 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9369 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9371 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9372 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9374 digest
[0] = byte_swap_32 (digest
[0]);
9375 digest
[1] = byte_swap_32 (digest
[1]);
9379 IP (digest
[0], digest
[1], tt
);
9381 digest
[0] = digest
[0];
9382 digest
[1] = digest
[1];
9389 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9391 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9393 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9395 salt_t
*salt
= hash_buf
->salt
;
9397 char *hash_pos
= input_buf
+ 8;
9399 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9400 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9401 digest
[2] = hex_to_uint (&hash_pos
[16]);
9402 digest
[3] = hex_to_uint (&hash_pos
[24]);
9403 digest
[4] = hex_to_uint (&hash_pos
[32]);
9405 digest
[0] -= SHA1M_A
;
9406 digest
[1] -= SHA1M_B
;
9407 digest
[2] -= SHA1M_C
;
9408 digest
[3] -= SHA1M_D
;
9409 digest
[4] -= SHA1M_E
;
9413 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9415 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9417 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9419 salt
->salt_len
= salt_len
;
9424 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9426 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9428 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9430 salt_t
*salt
= hash_buf
->salt
;
9432 char *hash_pos
= input_buf
+ 8;
9434 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9435 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9436 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9437 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9438 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9439 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9440 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9441 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9443 digest
[0] -= SHA512M_A
;
9444 digest
[1] -= SHA512M_B
;
9445 digest
[2] -= SHA512M_C
;
9446 digest
[3] -= SHA512M_D
;
9447 digest
[4] -= SHA512M_E
;
9448 digest
[5] -= SHA512M_F
;
9449 digest
[6] -= SHA512M_G
;
9450 digest
[7] -= SHA512M_H
;
9454 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9456 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9458 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9460 salt
->salt_len
= salt_len
;
9465 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9467 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9469 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9473 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9476 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9478 salt_t
*salt
= hash_buf
->salt
;
9480 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9481 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9482 digest
[2] = hex_to_uint (&input_buf
[16]);
9483 digest
[3] = hex_to_uint (&input_buf
[24]);
9485 digest
[0] = byte_swap_32 (digest
[0]);
9486 digest
[1] = byte_swap_32 (digest
[1]);
9487 digest
[2] = byte_swap_32 (digest
[2]);
9488 digest
[3] = byte_swap_32 (digest
[3]);
9490 digest
[0] -= MD5M_A
;
9491 digest
[1] -= MD5M_B
;
9492 digest
[2] -= MD5M_C
;
9493 digest
[3] -= MD5M_D
;
9495 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9497 uint salt_len
= input_len
- 32 - 1;
9499 char *salt_buf
= input_buf
+ 32 + 1;
9501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9503 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9505 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9507 salt
->salt_len
= salt_len
;
9512 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9514 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9516 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9520 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9525 char clean_input_buf
[32];
9527 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9528 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9530 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9534 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9540 clean_input_buf
[k
] = input_buf
[i
];
9548 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9550 salt_t
*salt
= hash_buf
->salt
;
9552 char a
, b
, c
, d
, e
, f
;
9554 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9555 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9556 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9557 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9558 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9559 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9561 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9562 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9564 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9565 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9566 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9567 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9568 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9569 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9571 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9572 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9574 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9575 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9576 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9577 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9578 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9579 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9581 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9582 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9584 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9585 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9586 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9587 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9588 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9589 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9591 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9592 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9594 digest
[0] = byte_swap_32 (digest
[0]);
9595 digest
[1] = byte_swap_32 (digest
[1]);
9596 digest
[2] = byte_swap_32 (digest
[2]);
9597 digest
[3] = byte_swap_32 (digest
[3]);
9599 digest
[0] -= MD5M_A
;
9600 digest
[1] -= MD5M_B
;
9601 digest
[2] -= MD5M_C
;
9602 digest
[3] -= MD5M_D
;
9604 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9606 uint salt_len
= input_len
- 30 - 1;
9608 char *salt_buf
= input_buf
+ 30 + 1;
9610 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9612 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9614 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9616 salt
->salt_len
= salt_len
;
9618 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9620 salt
->salt_len
+= 22;
9625 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9627 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9629 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9633 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9636 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9638 salt_t
*salt
= hash_buf
->salt
;
9640 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9641 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9642 digest
[2] = hex_to_uint (&input_buf
[16]);
9643 digest
[3] = hex_to_uint (&input_buf
[24]);
9644 digest
[4] = hex_to_uint (&input_buf
[32]);
9646 digest
[0] -= SHA1M_A
;
9647 digest
[1] -= SHA1M_B
;
9648 digest
[2] -= SHA1M_C
;
9649 digest
[3] -= SHA1M_D
;
9650 digest
[4] -= SHA1M_E
;
9652 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9654 uint salt_len
= input_len
- 40 - 1;
9656 char *salt_buf
= input_buf
+ 40 + 1;
9658 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9660 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9662 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9664 salt
->salt_len
= salt_len
;
9669 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9671 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9673 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9677 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9680 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9682 char *iter_pos
= input_buf
+ 6;
9684 salt_t
*salt
= hash_buf
->salt
;
9686 salt
->salt_iter
= atoi (iter_pos
) - 1;
9688 char *salt_pos
= strchr (iter_pos
, '#');
9690 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9694 char *digest_pos
= strchr (salt_pos
, '#');
9696 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9700 uint salt_len
= digest_pos
- salt_pos
- 1;
9702 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9704 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9705 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9706 digest
[2] = hex_to_uint (&digest_pos
[16]);
9707 digest
[3] = hex_to_uint (&digest_pos
[24]);
9709 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9711 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9713 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9715 salt
->salt_len
= salt_len
;
9720 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9722 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9724 salt_t
*salt
= hash_buf
->salt
;
9726 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9730 memcpy (&in
, input_buf
, input_len
);
9732 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9734 memcpy (digest
, in
.keymic
, 16);
9737 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9738 The phrase "Pairwise key expansion"
9739 Access Point Address (Referred to as Authenticator Address AA)
9740 Supplicant Address (referred to as Supplicant Address SA)
9741 Access Point Nonce (referred to as Authenticator Anonce)
9742 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9745 uint salt_len
= strlen (in
.essid
);
9747 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9749 salt
->salt_len
= salt_len
;
9751 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9753 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9755 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9757 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9759 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9760 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9764 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9765 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9768 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9770 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9771 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9775 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9776 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9779 for (int i
= 0; i
< 25; i
++)
9781 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9784 wpa
->keyver
= in
.keyver
;
9786 if (wpa
->keyver
> 255)
9788 log_info ("ATTENTION!");
9789 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9790 log_info (" This could be due to a recent aircrack-ng bug.");
9791 log_info (" The key version was automatically reset to a reasonable value.");
9794 wpa
->keyver
&= 0xff;
9797 wpa
->eapol_size
= in
.eapol_size
;
9799 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9801 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9803 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9805 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9807 if (wpa
->keyver
== 1)
9813 digest
[0] = byte_swap_32 (digest
[0]);
9814 digest
[1] = byte_swap_32 (digest
[1]);
9815 digest
[2] = byte_swap_32 (digest
[2]);
9816 digest
[3] = byte_swap_32 (digest
[3]);
9818 for (int i
= 0; i
< 64; i
++)
9820 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9824 salt
->salt_buf
[10] = digest
[1];
9825 salt
->salt_buf
[11] = digest
[2];
9830 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9832 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9834 salt_t
*salt
= hash_buf
->salt
;
9838 log_error ("Password Safe v2 container not specified");
9843 FILE *fp
= fopen (input_buf
, "rb");
9847 log_error ("%s: %s", input_buf
, strerror (errno
));
9856 uint32_t salt
[5]; // unused, but makes better valid check
9857 uint32_t iv
[2]; // unused, but makes better valid check
9863 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9867 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9869 salt
->salt_buf
[0] = buf
.random
[0];
9870 salt
->salt_buf
[1] = buf
.random
[1];
9873 salt
->salt_iter
= 1000;
9875 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9876 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9877 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9878 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9879 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9884 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9886 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9888 salt_t
*salt
= hash_buf
->salt
;
9892 log_error (".psafe3 not specified");
9897 FILE *fp
= fopen (input_buf
, "rb");
9901 log_error ("%s: %s", input_buf
, strerror (errno
));
9908 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9912 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9914 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9916 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9918 salt
->salt_iter
= in
.iterations
+ 1;
9920 salt
->salt_buf
[0] = in
.salt_buf
[0];
9921 salt
->salt_buf
[1] = in
.salt_buf
[1];
9922 salt
->salt_buf
[2] = in
.salt_buf
[2];
9923 salt
->salt_buf
[3] = in
.salt_buf
[3];
9924 salt
->salt_buf
[4] = in
.salt_buf
[4];
9925 salt
->salt_buf
[5] = in
.salt_buf
[5];
9926 salt
->salt_buf
[6] = in
.salt_buf
[6];
9927 salt
->salt_buf
[7] = in
.salt_buf
[7];
9929 salt
->salt_len
= 32;
9931 digest
[0] = in
.hash_buf
[0];
9932 digest
[1] = in
.hash_buf
[1];
9933 digest
[2] = in
.hash_buf
[2];
9934 digest
[3] = in
.hash_buf
[3];
9935 digest
[4] = in
.hash_buf
[4];
9936 digest
[5] = in
.hash_buf
[5];
9937 digest
[6] = in
.hash_buf
[6];
9938 digest
[7] = in
.hash_buf
[7];
9940 digest
[0] = byte_swap_32 (digest
[0]);
9941 digest
[1] = byte_swap_32 (digest
[1]);
9942 digest
[2] = byte_swap_32 (digest
[2]);
9943 digest
[3] = byte_swap_32 (digest
[3]);
9944 digest
[4] = byte_swap_32 (digest
[4]);
9945 digest
[5] = byte_swap_32 (digest
[5]);
9946 digest
[6] = byte_swap_32 (digest
[6]);
9947 digest
[7] = byte_swap_32 (digest
[7]);
9952 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9954 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
9956 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
9958 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9960 salt_t
*salt
= hash_buf
->salt
;
9962 char *iter_pos
= input_buf
+ 3;
9964 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
9966 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
9968 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
9970 salt
->salt_iter
= salt_iter
;
9972 char *salt_pos
= iter_pos
+ 1;
9976 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
9978 salt
->salt_len
= salt_len
;
9980 char *hash_pos
= salt_pos
+ salt_len
;
9982 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
9987 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9989 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
9991 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9993 salt_t
*salt
= hash_buf
->salt
;
9995 char *salt_pos
= input_buf
+ 3;
9997 uint iterations_len
= 0;
9999 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10003 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10005 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10006 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10010 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10014 iterations_len
+= 8;
10018 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10021 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10023 char *hash_pos
= strchr (salt_pos
, '$');
10025 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10027 uint salt_len
= hash_pos
- salt_pos
;
10029 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10031 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10033 salt
->salt_len
= salt_len
;
10037 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10039 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10041 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10043 return (PARSER_OK
);
10046 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10048 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10050 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10052 salt_t
*salt
= hash_buf
->salt
;
10054 char *salt_pos
= input_buf
+ 6;
10056 uint iterations_len
= 0;
10058 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10062 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10064 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10065 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10069 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10073 iterations_len
+= 8;
10077 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10080 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10082 char *hash_pos
= strchr (salt_pos
, '$');
10084 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10086 uint salt_len
= hash_pos
- salt_pos
;
10088 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10090 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10092 salt
->salt_len
= salt_len
;
10096 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10098 return (PARSER_OK
);
10101 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10103 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10105 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10107 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10109 salt_t
*salt
= hash_buf
->salt
;
10111 char *salt_pos
= input_buf
+ 14;
10113 char *hash_pos
= strchr (salt_pos
, '*');
10115 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10119 uint salt_len
= hash_pos
- salt_pos
- 1;
10121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10123 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10125 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10127 salt
->salt_len
= salt_len
;
10129 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10131 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10133 memcpy (digest
, tmp_buf
, 20);
10135 digest
[0] = byte_swap_32 (digest
[0]);
10136 digest
[1] = byte_swap_32 (digest
[1]);
10137 digest
[2] = byte_swap_32 (digest
[2]);
10138 digest
[3] = byte_swap_32 (digest
[3]);
10139 digest
[4] = byte_swap_32 (digest
[4]);
10141 digest
[0] -= SHA1M_A
;
10142 digest
[1] -= SHA1M_B
;
10143 digest
[2] -= SHA1M_C
;
10144 digest
[3] -= SHA1M_D
;
10145 digest
[4] -= SHA1M_E
;
10147 return (PARSER_OK
);
10150 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10152 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10154 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10156 if (c12
& 3) return (PARSER_HASH_VALUE
);
10158 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10160 salt_t
*salt
= hash_buf
->salt
;
10162 // for ascii_digest
10163 salt
->salt_sign
[0] = input_buf
[0];
10164 salt
->salt_sign
[1] = input_buf
[1];
10166 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10167 | itoa64_to_int (input_buf
[1]) << 6;
10169 salt
->salt_len
= 2;
10173 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10175 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10177 memcpy (digest
, tmp_buf
, 8);
10181 IP (digest
[0], digest
[1], tt
);
10186 return (PARSER_OK
);
10189 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10191 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10193 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10195 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10196 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10197 digest
[2] = hex_to_uint (&input_buf
[16]);
10198 digest
[3] = hex_to_uint (&input_buf
[24]);
10200 digest
[0] = byte_swap_32 (digest
[0]);
10201 digest
[1] = byte_swap_32 (digest
[1]);
10202 digest
[2] = byte_swap_32 (digest
[2]);
10203 digest
[3] = byte_swap_32 (digest
[3]);
10205 digest
[0] -= MD4M_A
;
10206 digest
[1] -= MD4M_B
;
10207 digest
[2] -= MD4M_C
;
10208 digest
[3] -= MD4M_D
;
10210 return (PARSER_OK
);
10213 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10215 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10217 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10221 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10224 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10226 salt_t
*salt
= hash_buf
->salt
;
10228 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10229 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10230 digest
[2] = hex_to_uint (&input_buf
[16]);
10231 digest
[3] = hex_to_uint (&input_buf
[24]);
10233 digest
[0] = byte_swap_32 (digest
[0]);
10234 digest
[1] = byte_swap_32 (digest
[1]);
10235 digest
[2] = byte_swap_32 (digest
[2]);
10236 digest
[3] = byte_swap_32 (digest
[3]);
10238 digest
[0] -= MD4M_A
;
10239 digest
[1] -= MD4M_B
;
10240 digest
[2] -= MD4M_C
;
10241 digest
[3] -= MD4M_D
;
10243 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10245 uint salt_len
= input_len
- 32 - 1;
10247 char *salt_buf
= input_buf
+ 32 + 1;
10249 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10251 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10253 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10255 salt
->salt_len
= salt_len
;
10257 return (PARSER_OK
);
10260 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10262 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10264 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10266 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10267 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10268 digest
[2] = hex_to_uint (&input_buf
[16]);
10269 digest
[3] = hex_to_uint (&input_buf
[24]);
10271 digest
[0] = byte_swap_32 (digest
[0]);
10272 digest
[1] = byte_swap_32 (digest
[1]);
10273 digest
[2] = byte_swap_32 (digest
[2]);
10274 digest
[3] = byte_swap_32 (digest
[3]);
10276 digest
[0] -= MD5M_A
;
10277 digest
[1] -= MD5M_B
;
10278 digest
[2] -= MD5M_C
;
10279 digest
[3] -= MD5M_D
;
10281 return (PARSER_OK
);
10284 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10286 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10288 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10290 digest
[0] = hex_to_uint (&input_buf
[0]);
10291 digest
[1] = hex_to_uint (&input_buf
[8]);
10295 digest
[0] = byte_swap_32 (digest
[0]);
10296 digest
[1] = byte_swap_32 (digest
[1]);
10298 return (PARSER_OK
);
10301 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10303 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10305 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10309 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10312 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10314 salt_t
*salt
= hash_buf
->salt
;
10316 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10317 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10318 digest
[2] = hex_to_uint (&input_buf
[16]);
10319 digest
[3] = hex_to_uint (&input_buf
[24]);
10321 digest
[0] = byte_swap_32 (digest
[0]);
10322 digest
[1] = byte_swap_32 (digest
[1]);
10323 digest
[2] = byte_swap_32 (digest
[2]);
10324 digest
[3] = byte_swap_32 (digest
[3]);
10326 digest
[0] -= MD5M_A
;
10327 digest
[1] -= MD5M_B
;
10328 digest
[2] -= MD5M_C
;
10329 digest
[3] -= MD5M_D
;
10331 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10333 uint salt_len
= input_len
- 32 - 1;
10335 char *salt_buf
= input_buf
+ 32 + 1;
10337 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10339 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10341 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10343 salt
->salt_len
= salt_len
;
10345 return (PARSER_OK
);
10348 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10350 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10352 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10354 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10355 | itoa64_to_int (input_buf
[ 1]) << 6
10356 | itoa64_to_int (input_buf
[ 2]) << 12
10357 | itoa64_to_int (input_buf
[ 3]) << 18;
10358 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10359 | itoa64_to_int (input_buf
[ 5]) << 6
10360 | itoa64_to_int (input_buf
[ 6]) << 12
10361 | itoa64_to_int (input_buf
[ 7]) << 18;
10362 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10363 | itoa64_to_int (input_buf
[ 9]) << 6
10364 | itoa64_to_int (input_buf
[10]) << 12
10365 | itoa64_to_int (input_buf
[11]) << 18;
10366 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10367 | itoa64_to_int (input_buf
[13]) << 6
10368 | itoa64_to_int (input_buf
[14]) << 12
10369 | itoa64_to_int (input_buf
[15]) << 18;
10371 digest
[0] -= MD5M_A
;
10372 digest
[1] -= MD5M_B
;
10373 digest
[2] -= MD5M_C
;
10374 digest
[3] -= MD5M_D
;
10376 digest
[0] &= 0x00ffffff;
10377 digest
[1] &= 0x00ffffff;
10378 digest
[2] &= 0x00ffffff;
10379 digest
[3] &= 0x00ffffff;
10381 return (PARSER_OK
);
10384 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10386 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10388 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10392 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10395 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10397 salt_t
*salt
= hash_buf
->salt
;
10399 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10400 | itoa64_to_int (input_buf
[ 1]) << 6
10401 | itoa64_to_int (input_buf
[ 2]) << 12
10402 | itoa64_to_int (input_buf
[ 3]) << 18;
10403 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10404 | itoa64_to_int (input_buf
[ 5]) << 6
10405 | itoa64_to_int (input_buf
[ 6]) << 12
10406 | itoa64_to_int (input_buf
[ 7]) << 18;
10407 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10408 | itoa64_to_int (input_buf
[ 9]) << 6
10409 | itoa64_to_int (input_buf
[10]) << 12
10410 | itoa64_to_int (input_buf
[11]) << 18;
10411 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10412 | itoa64_to_int (input_buf
[13]) << 6
10413 | itoa64_to_int (input_buf
[14]) << 12
10414 | itoa64_to_int (input_buf
[15]) << 18;
10416 digest
[0] -= MD5M_A
;
10417 digest
[1] -= MD5M_B
;
10418 digest
[2] -= MD5M_C
;
10419 digest
[3] -= MD5M_D
;
10421 digest
[0] &= 0x00ffffff;
10422 digest
[1] &= 0x00ffffff;
10423 digest
[2] &= 0x00ffffff;
10424 digest
[3] &= 0x00ffffff;
10426 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10428 uint salt_len
= input_len
- 16 - 1;
10430 char *salt_buf
= input_buf
+ 16 + 1;
10432 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10434 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10436 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10438 salt
->salt_len
= salt_len
;
10440 return (PARSER_OK
);
10443 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10445 key
[0] = (nthash
[0] >> 0);
10446 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10447 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10448 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10449 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10450 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10451 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10452 key
[7] = (nthash
[6] << 1);
10464 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10466 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10468 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10470 salt_t
*salt
= hash_buf
->salt
;
10472 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10478 char *user_pos
= input_buf
;
10480 char *unused_pos
= strchr (user_pos
, ':');
10482 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10484 uint user_len
= unused_pos
- user_pos
;
10486 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10490 char *domain_pos
= strchr (unused_pos
, ':');
10492 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10494 uint unused_len
= domain_pos
- unused_pos
;
10496 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10500 char *srvchall_pos
= strchr (domain_pos
, ':');
10502 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10504 uint domain_len
= srvchall_pos
- domain_pos
;
10506 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10510 char *hash_pos
= strchr (srvchall_pos
, ':');
10512 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10514 uint srvchall_len
= hash_pos
- srvchall_pos
;
10516 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10520 char *clichall_pos
= strchr (hash_pos
, ':');
10522 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10524 uint hash_len
= clichall_pos
- hash_pos
;
10526 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10530 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10532 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10535 * store some data for later use
10538 netntlm
->user_len
= user_len
* 2;
10539 netntlm
->domain_len
= domain_len
* 2;
10540 netntlm
->srvchall_len
= srvchall_len
/ 2;
10541 netntlm
->clichall_len
= clichall_len
/ 2;
10543 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10544 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10547 * handle username and domainname
10550 for (uint i
= 0; i
< user_len
; i
++)
10552 *userdomain_ptr
++ = user_pos
[i
];
10553 *userdomain_ptr
++ = 0;
10556 for (uint i
= 0; i
< domain_len
; i
++)
10558 *userdomain_ptr
++ = domain_pos
[i
];
10559 *userdomain_ptr
++ = 0;
10563 * handle server challenge encoding
10566 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10568 const char p0
= srvchall_pos
[i
+ 0];
10569 const char p1
= srvchall_pos
[i
+ 1];
10571 *chall_ptr
++ = hex_convert (p1
) << 0
10572 | hex_convert (p0
) << 4;
10576 * handle client challenge encoding
10579 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10581 const char p0
= clichall_pos
[i
+ 0];
10582 const char p1
= clichall_pos
[i
+ 1];
10584 *chall_ptr
++ = hex_convert (p1
) << 0
10585 | hex_convert (p0
) << 4;
10592 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10594 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10596 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10598 salt
->salt_len
= salt_len
;
10600 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10601 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10602 digest
[2] = hex_to_uint (&hash_pos
[16]);
10603 digest
[3] = hex_to_uint (&hash_pos
[24]);
10605 digest
[0] = byte_swap_32 (digest
[0]);
10606 digest
[1] = byte_swap_32 (digest
[1]);
10607 digest
[2] = byte_swap_32 (digest
[2]);
10608 digest
[3] = byte_swap_32 (digest
[3]);
10610 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10612 uint digest_tmp
[2];
10614 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10615 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10617 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10618 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10620 /* special case 2: ESS */
10622 if (srvchall_len
== 48)
10624 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10628 w
[ 0] = netntlm
->chall_buf
[6];
10629 w
[ 1] = netntlm
->chall_buf
[7];
10630 w
[ 2] = netntlm
->chall_buf
[0];
10631 w
[ 3] = netntlm
->chall_buf
[1];
10654 salt
->salt_buf
[0] = dgst
[0];
10655 salt
->salt_buf
[1] = dgst
[1];
10659 /* precompute netntlmv1 exploit start */
10661 for (uint i
= 0; i
< 0x10000; i
++)
10663 uint key_md4
[2] = { i
, 0 };
10664 uint key_des
[2] = { 0, 0 };
10666 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10671 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10673 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10675 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10677 if (data3
[0] != digest_tmp
[0]) continue;
10678 if (data3
[1] != digest_tmp
[1]) continue;
10680 salt
->salt_buf
[2] = i
;
10682 salt
->salt_len
= 24;
10687 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10688 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10690 /* precompute netntlmv1 exploit stop */
10694 IP (digest
[0], digest
[1], tt
);
10695 IP (digest
[2], digest
[3], tt
);
10697 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10698 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10699 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10700 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10702 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10704 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10705 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10707 return (PARSER_OK
);
10710 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10712 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10714 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10716 salt_t
*salt
= hash_buf
->salt
;
10718 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10724 char *user_pos
= input_buf
;
10726 char *unused_pos
= strchr (user_pos
, ':');
10728 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10730 uint user_len
= unused_pos
- user_pos
;
10732 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10736 char *domain_pos
= strchr (unused_pos
, ':');
10738 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10740 uint unused_len
= domain_pos
- unused_pos
;
10742 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10746 char *srvchall_pos
= strchr (domain_pos
, ':');
10748 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10750 uint domain_len
= srvchall_pos
- domain_pos
;
10752 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10756 char *hash_pos
= strchr (srvchall_pos
, ':');
10758 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10760 uint srvchall_len
= hash_pos
- srvchall_pos
;
10762 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10766 char *clichall_pos
= strchr (hash_pos
, ':');
10768 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10770 uint hash_len
= clichall_pos
- hash_pos
;
10772 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10776 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10778 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10780 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10783 * store some data for later use
10786 netntlm
->user_len
= user_len
* 2;
10787 netntlm
->domain_len
= domain_len
* 2;
10788 netntlm
->srvchall_len
= srvchall_len
/ 2;
10789 netntlm
->clichall_len
= clichall_len
/ 2;
10791 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10792 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10795 * handle username and domainname
10798 for (uint i
= 0; i
< user_len
; i
++)
10800 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10801 *userdomain_ptr
++ = 0;
10804 for (uint i
= 0; i
< domain_len
; i
++)
10806 *userdomain_ptr
++ = domain_pos
[i
];
10807 *userdomain_ptr
++ = 0;
10810 *userdomain_ptr
++ = 0x80;
10813 * handle server challenge encoding
10816 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10818 const char p0
= srvchall_pos
[i
+ 0];
10819 const char p1
= srvchall_pos
[i
+ 1];
10821 *chall_ptr
++ = hex_convert (p1
) << 0
10822 | hex_convert (p0
) << 4;
10826 * handle client challenge encoding
10829 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10831 const char p0
= clichall_pos
[i
+ 0];
10832 const char p1
= clichall_pos
[i
+ 1];
10834 *chall_ptr
++ = hex_convert (p1
) << 0
10835 | hex_convert (p0
) << 4;
10838 *chall_ptr
++ = 0x80;
10841 * handle hash itself
10844 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10845 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10846 digest
[2] = hex_to_uint (&hash_pos
[16]);
10847 digest
[3] = hex_to_uint (&hash_pos
[24]);
10849 digest
[0] = byte_swap_32 (digest
[0]);
10850 digest
[1] = byte_swap_32 (digest
[1]);
10851 digest
[2] = byte_swap_32 (digest
[2]);
10852 digest
[3] = byte_swap_32 (digest
[3]);
10855 * reuse challange data as salt_buf, its the buffer that is most likely unique
10858 salt
->salt_buf
[0] = 0;
10859 salt
->salt_buf
[1] = 0;
10860 salt
->salt_buf
[2] = 0;
10861 salt
->salt_buf
[3] = 0;
10862 salt
->salt_buf
[4] = 0;
10863 salt
->salt_buf
[5] = 0;
10864 salt
->salt_buf
[6] = 0;
10865 salt
->salt_buf
[7] = 0;
10869 uptr
= (uint
*) netntlm
->userdomain_buf
;
10871 for (uint i
= 0; i
< 16; i
+= 16)
10873 md5_64 (uptr
, salt
->salt_buf
);
10876 uptr
= (uint
*) netntlm
->chall_buf
;
10878 for (uint i
= 0; i
< 256; i
+= 16)
10880 md5_64 (uptr
, salt
->salt_buf
);
10883 salt
->salt_len
= 16;
10885 return (PARSER_OK
);
10888 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10890 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10892 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10896 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10899 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10901 salt_t
*salt
= hash_buf
->salt
;
10903 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10904 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10905 digest
[2] = hex_to_uint (&input_buf
[16]);
10906 digest
[3] = hex_to_uint (&input_buf
[24]);
10908 digest
[0] = byte_swap_32 (digest
[0]);
10909 digest
[1] = byte_swap_32 (digest
[1]);
10910 digest
[2] = byte_swap_32 (digest
[2]);
10911 digest
[3] = byte_swap_32 (digest
[3]);
10913 digest
[0] -= MD5M_A
;
10914 digest
[1] -= MD5M_B
;
10915 digest
[2] -= MD5M_C
;
10916 digest
[3] -= MD5M_D
;
10918 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10920 uint salt_len
= input_len
- 32 - 1;
10922 char *salt_buf
= input_buf
+ 32 + 1;
10924 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10926 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10928 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10930 salt
->salt_len
= salt_len
;
10932 return (PARSER_OK
);
10935 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10937 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10939 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10943 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
10946 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10948 salt_t
*salt
= hash_buf
->salt
;
10950 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10951 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10952 digest
[2] = hex_to_uint (&input_buf
[16]);
10953 digest
[3] = hex_to_uint (&input_buf
[24]);
10955 digest
[0] = byte_swap_32 (digest
[0]);
10956 digest
[1] = byte_swap_32 (digest
[1]);
10957 digest
[2] = byte_swap_32 (digest
[2]);
10958 digest
[3] = byte_swap_32 (digest
[3]);
10960 digest
[0] -= MD5M_A
;
10961 digest
[1] -= MD5M_B
;
10962 digest
[2] -= MD5M_C
;
10963 digest
[3] -= MD5M_D
;
10965 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10967 uint salt_len
= input_len
- 32 - 1;
10969 char *salt_buf
= input_buf
+ 32 + 1;
10971 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10973 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10975 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10977 salt
->salt_len
= salt_len
;
10979 return (PARSER_OK
);
10982 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10984 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
10986 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10988 salt_t
*salt
= hash_buf
->salt
;
10990 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10991 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10992 digest
[2] = hex_to_uint (&input_buf
[16]);
10993 digest
[3] = hex_to_uint (&input_buf
[24]);
10995 digest
[0] = byte_swap_32 (digest
[0]);
10996 digest
[1] = byte_swap_32 (digest
[1]);
10997 digest
[2] = byte_swap_32 (digest
[2]);
10998 digest
[3] = byte_swap_32 (digest
[3]);
11000 digest
[0] -= MD5M_A
;
11001 digest
[1] -= MD5M_B
;
11002 digest
[2] -= MD5M_C
;
11003 digest
[3] -= MD5M_D
;
11006 * This is a virtual salt. While the algorithm is basically not salted
11007 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11008 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11011 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11013 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11015 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11017 salt
->salt_len
= salt_len
;
11019 return (PARSER_OK
);
11022 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11024 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11026 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11030 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11033 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11035 salt_t
*salt
= hash_buf
->salt
;
11037 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11038 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11039 digest
[2] = hex_to_uint (&input_buf
[16]);
11040 digest
[3] = hex_to_uint (&input_buf
[24]);
11042 digest
[0] = byte_swap_32 (digest
[0]);
11043 digest
[1] = byte_swap_32 (digest
[1]);
11044 digest
[2] = byte_swap_32 (digest
[2]);
11045 digest
[3] = byte_swap_32 (digest
[3]);
11047 digest
[0] -= MD5M_A
;
11048 digest
[1] -= MD5M_B
;
11049 digest
[2] -= MD5M_C
;
11050 digest
[3] -= MD5M_D
;
11052 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11054 uint salt_len
= input_len
- 32 - 1;
11056 char *salt_buf
= input_buf
+ 32 + 1;
11058 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11062 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11064 salt
->salt_len
= salt_len
;
11066 return (PARSER_OK
);
11069 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11071 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11073 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11077 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11080 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11082 salt_t
*salt
= hash_buf
->salt
;
11084 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11085 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11086 digest
[2] = hex_to_uint (&input_buf
[16]);
11087 digest
[3] = hex_to_uint (&input_buf
[24]);
11089 digest
[0] = byte_swap_32 (digest
[0]);
11090 digest
[1] = byte_swap_32 (digest
[1]);
11091 digest
[2] = byte_swap_32 (digest
[2]);
11092 digest
[3] = byte_swap_32 (digest
[3]);
11094 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11096 uint salt_len
= input_len
- 32 - 1;
11098 char *salt_buf
= input_buf
+ 32 + 1;
11100 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11102 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11104 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11106 salt
->salt_len
= salt_len
;
11108 return (PARSER_OK
);
11111 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11113 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11115 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11119 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11122 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11124 salt_t
*salt
= hash_buf
->salt
;
11126 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11127 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11128 digest
[2] = hex_to_uint (&input_buf
[16]);
11129 digest
[3] = hex_to_uint (&input_buf
[24]);
11131 digest
[0] = byte_swap_32 (digest
[0]);
11132 digest
[1] = byte_swap_32 (digest
[1]);
11133 digest
[2] = byte_swap_32 (digest
[2]);
11134 digest
[3] = byte_swap_32 (digest
[3]);
11136 digest
[0] -= MD4M_A
;
11137 digest
[1] -= MD4M_B
;
11138 digest
[2] -= MD4M_C
;
11139 digest
[3] -= MD4M_D
;
11141 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11143 uint salt_len
= input_len
- 32 - 1;
11145 char *salt_buf
= input_buf
+ 32 + 1;
11147 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11149 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11151 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11153 salt
->salt_len
= salt_len
;
11155 return (PARSER_OK
);
11158 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11160 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11162 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11166 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11169 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11171 salt_t
*salt
= hash_buf
->salt
;
11173 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11174 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11175 digest
[2] = hex_to_uint (&input_buf
[16]);
11176 digest
[3] = hex_to_uint (&input_buf
[24]);
11178 digest
[0] = byte_swap_32 (digest
[0]);
11179 digest
[1] = byte_swap_32 (digest
[1]);
11180 digest
[2] = byte_swap_32 (digest
[2]);
11181 digest
[3] = byte_swap_32 (digest
[3]);
11183 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11185 uint salt_len
= input_len
- 32 - 1;
11187 char *salt_buf
= input_buf
+ 32 + 1;
11189 uint salt_pc_block
[16];
11191 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11193 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11195 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11199 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11201 salt_pc_block
[14] = salt_len
* 8;
11203 uint salt_pc_digest
[4];
11205 salt_pc_digest
[0] = MAGIC_A
;
11206 salt_pc_digest
[1] = MAGIC_B
;
11207 salt_pc_digest
[2] = MAGIC_C
;
11208 salt_pc_digest
[3] = MAGIC_D
;
11210 md5_64 (salt_pc_block
, salt_pc_digest
);
11212 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11213 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11214 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11215 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11217 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11219 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11221 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11223 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11224 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11225 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11226 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11228 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11230 return (PARSER_OK
);
11233 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11235 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11237 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11239 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11240 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11241 digest
[2] = hex_to_uint (&input_buf
[16]);
11242 digest
[3] = hex_to_uint (&input_buf
[24]);
11243 digest
[4] = hex_to_uint (&input_buf
[32]);
11245 digest
[0] -= SHA1M_A
;
11246 digest
[1] -= SHA1M_B
;
11247 digest
[2] -= SHA1M_C
;
11248 digest
[3] -= SHA1M_D
;
11249 digest
[4] -= SHA1M_E
;
11251 return (PARSER_OK
);
11254 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11256 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11258 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11260 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11261 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11262 digest
[2] = hex_to_uint (&input_buf
[16]);
11263 digest
[3] = hex_to_uint (&input_buf
[24]);
11264 digest
[4] = hex_to_uint (&input_buf
[32]);
11266 return (PARSER_OK
);
11269 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11271 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11273 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11277 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11280 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11282 salt_t
*salt
= hash_buf
->salt
;
11284 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11285 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11286 digest
[2] = hex_to_uint (&input_buf
[16]);
11287 digest
[3] = hex_to_uint (&input_buf
[24]);
11288 digest
[4] = hex_to_uint (&input_buf
[32]);
11290 digest
[0] -= SHA1M_A
;
11291 digest
[1] -= SHA1M_B
;
11292 digest
[2] -= SHA1M_C
;
11293 digest
[3] -= SHA1M_D
;
11294 digest
[4] -= SHA1M_E
;
11296 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11298 uint salt_len
= input_len
- 40 - 1;
11300 char *salt_buf
= input_buf
+ 40 + 1;
11302 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11304 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11306 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11308 salt
->salt_len
= salt_len
;
11310 return (PARSER_OK
);
11313 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11315 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11317 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11319 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11323 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11325 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11327 memcpy (digest
, tmp_buf
, 20);
11329 digest
[0] = byte_swap_32 (digest
[0]);
11330 digest
[1] = byte_swap_32 (digest
[1]);
11331 digest
[2] = byte_swap_32 (digest
[2]);
11332 digest
[3] = byte_swap_32 (digest
[3]);
11333 digest
[4] = byte_swap_32 (digest
[4]);
11335 digest
[0] -= SHA1M_A
;
11336 digest
[1] -= SHA1M_B
;
11337 digest
[2] -= SHA1M_C
;
11338 digest
[3] -= SHA1M_D
;
11339 digest
[4] -= SHA1M_E
;
11341 return (PARSER_OK
);
11344 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11346 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11348 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11350 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11352 salt_t
*salt
= hash_buf
->salt
;
11356 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11358 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11360 memcpy (digest
, tmp_buf
, 20);
11362 salt
->salt_len
= tmp_len
- 20;
11364 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11366 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11368 char *ptr
= (char *) salt
->salt_buf
;
11370 ptr
[salt
->salt_len
] = 0x80;
11373 digest
[0] = byte_swap_32 (digest
[0]);
11374 digest
[1] = byte_swap_32 (digest
[1]);
11375 digest
[2] = byte_swap_32 (digest
[2]);
11376 digest
[3] = byte_swap_32 (digest
[3]);
11377 digest
[4] = byte_swap_32 (digest
[4]);
11379 digest
[0] -= SHA1M_A
;
11380 digest
[1] -= SHA1M_B
;
11381 digest
[2] -= SHA1M_C
;
11382 digest
[3] -= SHA1M_D
;
11383 digest
[4] -= SHA1M_E
;
11385 return (PARSER_OK
);
11388 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11390 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11392 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11394 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11396 salt_t
*salt
= hash_buf
->salt
;
11398 char *salt_buf
= input_buf
+ 6;
11402 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11404 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11406 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11408 salt
->salt_len
= salt_len
;
11410 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11412 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11413 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11414 digest
[2] = hex_to_uint (&hash_pos
[16]);
11415 digest
[3] = hex_to_uint (&hash_pos
[24]);
11416 digest
[4] = hex_to_uint (&hash_pos
[32]);
11418 digest
[0] -= SHA1M_A
;
11419 digest
[1] -= SHA1M_B
;
11420 digest
[2] -= SHA1M_C
;
11421 digest
[3] -= SHA1M_D
;
11422 digest
[4] -= SHA1M_E
;
11424 return (PARSER_OK
);
11427 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11429 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11431 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11433 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11435 salt_t
*salt
= hash_buf
->salt
;
11437 char *salt_buf
= input_buf
+ 6;
11441 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11443 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11445 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11447 salt
->salt_len
= salt_len
;
11449 char *hash_pos
= input_buf
+ 6 + 8;
11451 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11452 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11453 digest
[2] = hex_to_uint (&hash_pos
[16]);
11454 digest
[3] = hex_to_uint (&hash_pos
[24]);
11455 digest
[4] = hex_to_uint (&hash_pos
[32]);
11457 digest
[0] -= SHA1M_A
;
11458 digest
[1] -= SHA1M_B
;
11459 digest
[2] -= SHA1M_C
;
11460 digest
[3] -= SHA1M_D
;
11461 digest
[4] -= SHA1M_E
;
11463 return (PARSER_OK
);
11466 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11468 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11470 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11472 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11474 salt_t
*salt
= hash_buf
->salt
;
11476 char *salt_buf
= input_buf
+ 6;
11480 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11482 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11484 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11486 salt
->salt_len
= salt_len
;
11488 char *hash_pos
= input_buf
+ 6 + 8;
11490 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11491 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11492 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11493 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11494 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11495 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11496 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11497 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11499 digest
[0] -= SHA512M_A
;
11500 digest
[1] -= SHA512M_B
;
11501 digest
[2] -= SHA512M_C
;
11502 digest
[3] -= SHA512M_D
;
11503 digest
[4] -= SHA512M_E
;
11504 digest
[5] -= SHA512M_F
;
11505 digest
[6] -= SHA512M_G
;
11506 digest
[7] -= SHA512M_H
;
11508 return (PARSER_OK
);
11511 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11513 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11515 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11519 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11522 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11524 salt_t
*salt
= hash_buf
->salt
;
11526 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11527 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11531 digest
[0] = byte_swap_32 (digest
[0]);
11532 digest
[1] = byte_swap_32 (digest
[1]);
11534 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11536 uint salt_len
= input_len
- 16 - 1;
11538 char *salt_buf
= input_buf
+ 16 + 1;
11540 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11542 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11544 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11546 salt
->salt_len
= salt_len
;
11548 return (PARSER_OK
);
11551 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11553 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11555 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11557 salt_t
*salt
= hash_buf
->salt
;
11559 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11560 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11561 digest
[2] = hex_to_uint (&input_buf
[16]);
11562 digest
[3] = hex_to_uint (&input_buf
[24]);
11563 digest
[4] = hex_to_uint (&input_buf
[32]);
11565 digest
[0] -= SHA1M_A
;
11566 digest
[1] -= SHA1M_B
;
11567 digest
[2] -= SHA1M_C
;
11568 digest
[3] -= SHA1M_D
;
11569 digest
[4] -= SHA1M_E
;
11571 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11573 uint salt_len
= input_len
- 40 - 1;
11575 char *salt_buf
= input_buf
+ 40 + 1;
11577 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11579 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11581 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11583 salt
->salt_len
= salt_len
;
11585 return (PARSER_OK
);
11588 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11590 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11592 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11594 salt_t
*salt
= hash_buf
->salt
;
11596 char *hash_pos
= input_buf
;
11598 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11599 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11600 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11601 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11602 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11603 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11604 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11605 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11606 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11607 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11608 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11609 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11610 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11611 digest
[13] = hex_to_uint (&hash_pos
[104]);
11612 digest
[14] = hex_to_uint (&hash_pos
[112]);
11613 digest
[15] = hex_to_uint (&hash_pos
[120]);
11615 char *salt_pos
= input_buf
+ 128;
11617 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11618 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11619 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11620 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11622 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11623 salt
->salt_len
= 16;
11625 return (PARSER_OK
);
11628 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11630 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11632 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11634 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11635 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11636 digest
[2] = hex_to_uint (&input_buf
[16]);
11637 digest
[3] = hex_to_uint (&input_buf
[24]);
11638 digest
[4] = hex_to_uint (&input_buf
[32]);
11639 digest
[5] = hex_to_uint (&input_buf
[40]);
11640 digest
[6] = hex_to_uint (&input_buf
[48]);
11641 digest
[7] = hex_to_uint (&input_buf
[56]);
11643 digest
[0] -= SHA256M_A
;
11644 digest
[1] -= SHA256M_B
;
11645 digest
[2] -= SHA256M_C
;
11646 digest
[3] -= SHA256M_D
;
11647 digest
[4] -= SHA256M_E
;
11648 digest
[5] -= SHA256M_F
;
11649 digest
[6] -= SHA256M_G
;
11650 digest
[7] -= SHA256M_H
;
11652 return (PARSER_OK
);
11655 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11657 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11659 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11663 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11666 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11668 salt_t
*salt
= hash_buf
->salt
;
11670 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11671 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11672 digest
[2] = hex_to_uint (&input_buf
[16]);
11673 digest
[3] = hex_to_uint (&input_buf
[24]);
11674 digest
[4] = hex_to_uint (&input_buf
[32]);
11675 digest
[5] = hex_to_uint (&input_buf
[40]);
11676 digest
[6] = hex_to_uint (&input_buf
[48]);
11677 digest
[7] = hex_to_uint (&input_buf
[56]);
11679 digest
[0] -= SHA256M_A
;
11680 digest
[1] -= SHA256M_B
;
11681 digest
[2] -= SHA256M_C
;
11682 digest
[3] -= SHA256M_D
;
11683 digest
[4] -= SHA256M_E
;
11684 digest
[5] -= SHA256M_F
;
11685 digest
[6] -= SHA256M_G
;
11686 digest
[7] -= SHA256M_H
;
11688 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11690 uint salt_len
= input_len
- 64 - 1;
11692 char *salt_buf
= input_buf
+ 64 + 1;
11694 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11696 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11698 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11700 salt
->salt_len
= salt_len
;
11702 return (PARSER_OK
);
11705 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11707 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11709 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11711 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11712 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11713 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11714 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11715 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11716 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11720 digest
[0] -= SHA384M_A
;
11721 digest
[1] -= SHA384M_B
;
11722 digest
[2] -= SHA384M_C
;
11723 digest
[3] -= SHA384M_D
;
11724 digest
[4] -= SHA384M_E
;
11725 digest
[5] -= SHA384M_F
;
11729 return (PARSER_OK
);
11732 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11734 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11736 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11738 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11739 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11740 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11741 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11742 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11743 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11744 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11745 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11747 digest
[0] -= SHA512M_A
;
11748 digest
[1] -= SHA512M_B
;
11749 digest
[2] -= SHA512M_C
;
11750 digest
[3] -= SHA512M_D
;
11751 digest
[4] -= SHA512M_E
;
11752 digest
[5] -= SHA512M_F
;
11753 digest
[6] -= SHA512M_G
;
11754 digest
[7] -= SHA512M_H
;
11756 return (PARSER_OK
);
11759 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11761 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11763 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11767 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11770 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11772 salt_t
*salt
= hash_buf
->salt
;
11774 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11775 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11776 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11777 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11778 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11779 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11780 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11781 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11783 digest
[0] -= SHA512M_A
;
11784 digest
[1] -= SHA512M_B
;
11785 digest
[2] -= SHA512M_C
;
11786 digest
[3] -= SHA512M_D
;
11787 digest
[4] -= SHA512M_E
;
11788 digest
[5] -= SHA512M_F
;
11789 digest
[6] -= SHA512M_G
;
11790 digest
[7] -= SHA512M_H
;
11792 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11794 uint salt_len
= input_len
- 128 - 1;
11796 char *salt_buf
= input_buf
+ 128 + 1;
11798 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11800 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11802 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11804 salt
->salt_len
= salt_len
;
11806 return (PARSER_OK
);
11809 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11811 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11813 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11815 salt_t
*salt
= hash_buf
->salt
;
11817 char *salt_pos
= input_buf
+ 3;
11819 uint iterations_len
= 0;
11821 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11825 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11827 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11828 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11832 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11836 iterations_len
+= 8;
11840 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11843 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11845 char *hash_pos
= strchr (salt_pos
, '$');
11847 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11849 uint salt_len
= hash_pos
- salt_pos
;
11851 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11853 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11855 salt
->salt_len
= salt_len
;
11859 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11861 return (PARSER_OK
);
11864 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11866 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11868 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11870 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11872 salt_t
*salt
= hash_buf
->salt
;
11874 uint keccak_mdlen
= input_len
/ 2;
11876 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11878 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11880 digest
[i
] = byte_swap_64 (digest
[i
]);
11883 salt
->keccak_mdlen
= keccak_mdlen
;
11885 return (PARSER_OK
);
11888 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11890 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11892 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11894 salt_t
*salt
= hash_buf
->salt
;
11896 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11899 * Parse that strange long line
11906 in_off
[0] = strtok (input_buf
, ":");
11908 in_len
[0] = strlen (in_off
[0]);
11912 for (i
= 1; i
< 9; i
++)
11914 in_off
[i
] = strtok (NULL
, ":");
11916 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11918 in_len
[i
] = strlen (in_off
[i
]);
11923 ptr
= (char *) ikepsk
->msg_buf
;
11925 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11926 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11927 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11928 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11929 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11930 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11934 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11936 ptr
= (char *) ikepsk
->nr_buf
;
11938 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11939 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11943 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
11946 * Store to database
11951 digest
[0] = hex_to_uint (&ptr
[ 0]);
11952 digest
[1] = hex_to_uint (&ptr
[ 8]);
11953 digest
[2] = hex_to_uint (&ptr
[16]);
11954 digest
[3] = hex_to_uint (&ptr
[24]);
11956 digest
[0] = byte_swap_32 (digest
[0]);
11957 digest
[1] = byte_swap_32 (digest
[1]);
11958 digest
[2] = byte_swap_32 (digest
[2]);
11959 digest
[3] = byte_swap_32 (digest
[3]);
11961 salt
->salt_len
= 32;
11963 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
11964 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
11965 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
11966 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
11967 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
11968 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
11969 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
11970 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
11972 return (PARSER_OK
);
11975 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11977 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
11979 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11981 salt_t
*salt
= hash_buf
->salt
;
11983 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11986 * Parse that strange long line
11993 in_off
[0] = strtok (input_buf
, ":");
11995 in_len
[0] = strlen (in_off
[0]);
11999 for (i
= 1; i
< 9; i
++)
12001 in_off
[i
] = strtok (NULL
, ":");
12003 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12005 in_len
[i
] = strlen (in_off
[i
]);
12010 ptr
= (char *) ikepsk
->msg_buf
;
12012 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12013 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12014 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12015 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12016 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12017 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12021 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12023 ptr
= (char *) ikepsk
->nr_buf
;
12025 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12026 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12030 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12033 * Store to database
12038 digest
[0] = hex_to_uint (&ptr
[ 0]);
12039 digest
[1] = hex_to_uint (&ptr
[ 8]);
12040 digest
[2] = hex_to_uint (&ptr
[16]);
12041 digest
[3] = hex_to_uint (&ptr
[24]);
12042 digest
[4] = hex_to_uint (&ptr
[32]);
12044 salt
->salt_len
= 32;
12046 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12047 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12048 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12049 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12050 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12051 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12052 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12053 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12055 return (PARSER_OK
);
12058 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12060 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12062 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12064 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12065 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12066 digest
[2] = hex_to_uint (&input_buf
[16]);
12067 digest
[3] = hex_to_uint (&input_buf
[24]);
12068 digest
[4] = hex_to_uint (&input_buf
[32]);
12070 digest
[0] = byte_swap_32 (digest
[0]);
12071 digest
[1] = byte_swap_32 (digest
[1]);
12072 digest
[2] = byte_swap_32 (digest
[2]);
12073 digest
[3] = byte_swap_32 (digest
[3]);
12074 digest
[4] = byte_swap_32 (digest
[4]);
12076 return (PARSER_OK
);
12079 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12081 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12083 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12085 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12086 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12087 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12088 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12089 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12090 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12091 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12092 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12093 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12094 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12095 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12096 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12097 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12098 digest
[13] = hex_to_uint (&input_buf
[104]);
12099 digest
[14] = hex_to_uint (&input_buf
[112]);
12100 digest
[15] = hex_to_uint (&input_buf
[120]);
12102 return (PARSER_OK
);
12105 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12107 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12109 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12111 salt_t
*salt
= hash_buf
->salt
;
12113 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12114 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12115 digest
[2] = hex_to_uint (&input_buf
[16]);
12116 digest
[3] = hex_to_uint (&input_buf
[24]);
12117 digest
[4] = hex_to_uint (&input_buf
[32]);
12119 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12121 uint salt_len
= input_len
- 40 - 1;
12123 char *salt_buf
= input_buf
+ 40 + 1;
12125 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12127 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12129 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12131 salt
->salt_len
= salt_len
;
12133 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12135 return (PARSER_OK
);
12138 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12140 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12142 salt_t
*salt
= hash_buf
->salt
;
12144 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12146 if (input_len
== 0)
12148 log_error ("TrueCrypt container not specified");
12153 FILE *fp
= fopen (input_buf
, "rb");
12157 log_error ("%s: %s", input_buf
, strerror (errno
));
12164 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12168 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12170 memcpy (tc
->salt_buf
, buf
, 64);
12172 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12174 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12176 salt
->salt_len
= 4;
12178 salt
->salt_iter
= 1000 - 1;
12180 digest
[0] = tc
->data_buf
[0];
12182 return (PARSER_OK
);
12185 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12187 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12189 salt_t
*salt
= hash_buf
->salt
;
12191 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12193 if (input_len
== 0)
12195 log_error ("TrueCrypt container not specified");
12200 FILE *fp
= fopen (input_buf
, "rb");
12204 log_error ("%s: %s", input_buf
, strerror (errno
));
12211 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12215 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12217 memcpy (tc
->salt_buf
, buf
, 64);
12219 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12221 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12223 salt
->salt_len
= 4;
12225 salt
->salt_iter
= 2000 - 1;
12227 digest
[0] = tc
->data_buf
[0];
12229 return (PARSER_OK
);
12232 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12234 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12236 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12238 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12240 salt_t
*salt
= hash_buf
->salt
;
12242 char *salt_pos
= input_buf
+ 6;
12244 char *hash_pos
= strchr (salt_pos
, '$');
12246 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12248 uint salt_len
= hash_pos
- salt_pos
;
12250 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12252 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12254 salt
->salt_len
= salt_len
;
12256 salt
->salt_iter
= 1000;
12260 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12262 return (PARSER_OK
);
12265 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12267 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12269 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12271 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12273 salt_t
*salt
= hash_buf
->salt
;
12275 char *iter_pos
= input_buf
+ 7;
12277 char *salt_pos
= strchr (iter_pos
, '$');
12279 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12283 char *hash_pos
= strchr (salt_pos
, '$');
12285 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12287 uint salt_len
= hash_pos
- salt_pos
;
12289 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12291 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12293 salt
->salt_len
= salt_len
;
12295 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12297 salt
->salt_sign
[0] = atoi (salt_iter
);
12299 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12303 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12305 digest
[0] = byte_swap_32 (digest
[0]);
12306 digest
[1] = byte_swap_32 (digest
[1]);
12307 digest
[2] = byte_swap_32 (digest
[2]);
12308 digest
[3] = byte_swap_32 (digest
[3]);
12309 digest
[4] = byte_swap_32 (digest
[4]);
12311 return (PARSER_OK
);
12314 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12316 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12318 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12320 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12322 salt_t
*salt
= hash_buf
->salt
;
12324 char *iter_pos
= input_buf
+ 9;
12326 char *salt_pos
= strchr (iter_pos
, '$');
12328 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12332 char *hash_pos
= strchr (salt_pos
, '$');
12334 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12336 uint salt_len
= hash_pos
- salt_pos
;
12338 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12340 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12342 salt
->salt_len
= salt_len
;
12344 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12346 salt
->salt_sign
[0] = atoi (salt_iter
);
12348 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12352 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12354 digest
[0] = byte_swap_32 (digest
[0]);
12355 digest
[1] = byte_swap_32 (digest
[1]);
12356 digest
[2] = byte_swap_32 (digest
[2]);
12357 digest
[3] = byte_swap_32 (digest
[3]);
12358 digest
[4] = byte_swap_32 (digest
[4]);
12359 digest
[5] = byte_swap_32 (digest
[5]);
12360 digest
[6] = byte_swap_32 (digest
[6]);
12361 digest
[7] = byte_swap_32 (digest
[7]);
12363 return (PARSER_OK
);
12366 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12368 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12370 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12372 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12374 salt_t
*salt
= hash_buf
->salt
;
12376 char *iter_pos
= input_buf
+ 9;
12378 char *salt_pos
= strchr (iter_pos
, '$');
12380 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12384 char *hash_pos
= strchr (salt_pos
, '$');
12386 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12388 uint salt_len
= hash_pos
- salt_pos
;
12390 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12392 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12394 salt
->salt_len
= salt_len
;
12396 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12398 salt
->salt_sign
[0] = atoi (salt_iter
);
12400 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12404 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12406 digest
[0] = byte_swap_64 (digest
[0]);
12407 digest
[1] = byte_swap_64 (digest
[1]);
12408 digest
[2] = byte_swap_64 (digest
[2]);
12409 digest
[3] = byte_swap_64 (digest
[3]);
12410 digest
[4] = byte_swap_64 (digest
[4]);
12411 digest
[5] = byte_swap_64 (digest
[5]);
12412 digest
[6] = byte_swap_64 (digest
[6]);
12413 digest
[7] = byte_swap_64 (digest
[7]);
12415 return (PARSER_OK
);
12418 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12420 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12422 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12424 salt_t
*salt
= hash_buf
->salt
;
12426 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12432 char *iterations_pos
= input_buf
;
12434 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12436 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12438 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12440 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12444 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12446 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12448 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12450 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12452 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12454 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12459 * pbkdf2 iterations
12462 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12465 * handle salt encoding
12468 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12470 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12472 const char p0
= saltbuf_pos
[i
+ 0];
12473 const char p1
= saltbuf_pos
[i
+ 1];
12475 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12476 | hex_convert (p0
) << 4;
12479 salt
->salt_len
= saltbuf_len
/ 2;
12482 * handle cipher encoding
12485 uint
*tmp
= (uint
*) mymalloc (32);
12487 char *cipherbuf_ptr
= (char *) tmp
;
12489 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12491 const char p0
= cipherbuf_pos
[i
+ 0];
12492 const char p1
= cipherbuf_pos
[i
+ 1];
12494 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12495 | hex_convert (p0
) << 4;
12498 // iv is stored at salt_buf 4 (length 16)
12499 // data is stored at salt_buf 8 (length 16)
12501 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12502 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12503 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12504 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12506 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12507 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12508 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12509 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12513 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12515 const char p0
= cipherbuf_pos
[j
+ 0];
12516 const char p1
= cipherbuf_pos
[j
+ 1];
12518 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12519 | hex_convert (p0
) << 4;
12526 digest
[0] = 0x10101010;
12527 digest
[1] = 0x10101010;
12528 digest
[2] = 0x10101010;
12529 digest
[3] = 0x10101010;
12531 return (PARSER_OK
);
12534 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12536 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12538 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12540 salt_t
*salt
= hash_buf
->salt
;
12542 char *hashbuf_pos
= input_buf
;
12544 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12546 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12548 uint hash_len
= iterations_pos
- hashbuf_pos
;
12550 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12554 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12556 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12558 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12562 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12564 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12566 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12568 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12570 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12572 salt
->salt_len
= salt_len
;
12574 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12576 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12577 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12578 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12579 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12581 return (PARSER_OK
);
12584 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12586 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12588 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12590 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12591 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12592 digest
[2] = hex_to_uint (&input_buf
[16]);
12593 digest
[3] = hex_to_uint (&input_buf
[24]);
12594 digest
[4] = hex_to_uint (&input_buf
[32]);
12595 digest
[5] = hex_to_uint (&input_buf
[40]);
12596 digest
[6] = hex_to_uint (&input_buf
[48]);
12597 digest
[7] = hex_to_uint (&input_buf
[56]);
12599 digest
[0] = byte_swap_32 (digest
[0]);
12600 digest
[1] = byte_swap_32 (digest
[1]);
12601 digest
[2] = byte_swap_32 (digest
[2]);
12602 digest
[3] = byte_swap_32 (digest
[3]);
12603 digest
[4] = byte_swap_32 (digest
[4]);
12604 digest
[5] = byte_swap_32 (digest
[5]);
12605 digest
[6] = byte_swap_32 (digest
[6]);
12606 digest
[7] = byte_swap_32 (digest
[7]);
12608 return (PARSER_OK
);
12611 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12613 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12615 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12617 salt_t
*salt
= hash_buf
->salt
;
12619 char *salt_pos
= input_buf
+ 3;
12621 uint iterations_len
= 0;
12623 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12627 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12629 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12630 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12634 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12638 iterations_len
+= 8;
12642 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12645 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12647 char *hash_pos
= strchr (salt_pos
, '$');
12649 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12651 uint salt_len
= hash_pos
- salt_pos
;
12653 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12655 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12657 salt
->salt_len
= salt_len
;
12661 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12663 return (PARSER_OK
);
12666 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12668 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12670 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12672 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12674 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12676 salt_t
*salt
= hash_buf
->salt
;
12678 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12680 char *iter_pos
= input_buf
+ 4;
12682 char *salt_pos
= strchr (iter_pos
, '$');
12684 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12688 char *hash_pos
= strchr (salt_pos
, '$');
12690 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12692 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12696 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12697 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12698 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12699 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12700 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12701 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12702 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12703 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12705 uint salt_len
= hash_pos
- salt_pos
- 1;
12707 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12709 salt
->salt_len
= salt_len
/ 2;
12711 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12712 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12713 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12714 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12715 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12716 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12717 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12718 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12720 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12721 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12722 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12723 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12724 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12725 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12726 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12727 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12728 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12729 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12731 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12733 salt
->salt_iter
= atoi (iter_pos
) - 1;
12735 return (PARSER_OK
);
12738 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12740 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12742 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12744 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12746 salt_t
*salt
= hash_buf
->salt
;
12748 char *salt_pos
= input_buf
+ 14;
12750 char *hash_pos
= strchr (salt_pos
, '*');
12752 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12756 uint salt_len
= hash_pos
- salt_pos
- 1;
12758 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12760 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12762 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12764 salt
->salt_len
= salt_len
;
12766 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12768 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12770 memcpy (digest
, tmp_buf
, 32);
12772 digest
[0] = byte_swap_32 (digest
[0]);
12773 digest
[1] = byte_swap_32 (digest
[1]);
12774 digest
[2] = byte_swap_32 (digest
[2]);
12775 digest
[3] = byte_swap_32 (digest
[3]);
12776 digest
[4] = byte_swap_32 (digest
[4]);
12777 digest
[5] = byte_swap_32 (digest
[5]);
12778 digest
[6] = byte_swap_32 (digest
[6]);
12779 digest
[7] = byte_swap_32 (digest
[7]);
12781 digest
[0] -= SHA256M_A
;
12782 digest
[1] -= SHA256M_B
;
12783 digest
[2] -= SHA256M_C
;
12784 digest
[3] -= SHA256M_D
;
12785 digest
[4] -= SHA256M_E
;
12786 digest
[5] -= SHA256M_F
;
12787 digest
[6] -= SHA256M_G
;
12788 digest
[7] -= SHA256M_H
;
12790 return (PARSER_OK
);
12793 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12795 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12797 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12799 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12801 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12803 salt_t
*salt
= hash_buf
->salt
;
12805 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12807 char *iter_pos
= input_buf
+ 19;
12809 char *salt_pos
= strchr (iter_pos
, '.');
12811 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12815 char *hash_pos
= strchr (salt_pos
, '.');
12817 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12819 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12823 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12824 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12825 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12826 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12827 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12828 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12829 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12830 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12832 uint salt_len
= hash_pos
- salt_pos
- 1;
12836 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12840 for (i
= 0; i
< salt_len
; i
++)
12842 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12845 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12846 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12848 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12850 salt
->salt_len
= salt_len
;
12852 salt
->salt_iter
= atoi (iter_pos
) - 1;
12854 return (PARSER_OK
);
12857 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12859 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12861 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12863 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12865 salt_t
*salt
= hash_buf
->salt
;
12869 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12871 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12873 memcpy (digest
, tmp_buf
, 64);
12875 digest
[0] = byte_swap_64 (digest
[0]);
12876 digest
[1] = byte_swap_64 (digest
[1]);
12877 digest
[2] = byte_swap_64 (digest
[2]);
12878 digest
[3] = byte_swap_64 (digest
[3]);
12879 digest
[4] = byte_swap_64 (digest
[4]);
12880 digest
[5] = byte_swap_64 (digest
[5]);
12881 digest
[6] = byte_swap_64 (digest
[6]);
12882 digest
[7] = byte_swap_64 (digest
[7]);
12884 digest
[0] -= SHA512M_A
;
12885 digest
[1] -= SHA512M_B
;
12886 digest
[2] -= SHA512M_C
;
12887 digest
[3] -= SHA512M_D
;
12888 digest
[4] -= SHA512M_E
;
12889 digest
[5] -= SHA512M_F
;
12890 digest
[6] -= SHA512M_G
;
12891 digest
[7] -= SHA512M_H
;
12893 salt
->salt_len
= tmp_len
- 64;
12895 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12897 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12899 char *ptr
= (char *) salt
->salt_buf
;
12901 ptr
[salt
->salt_len
] = 0x80;
12904 return (PARSER_OK
);
12907 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12909 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12911 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12915 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12918 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12920 salt_t
*salt
= hash_buf
->salt
;
12922 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12923 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12924 digest
[2] = hex_to_uint (&input_buf
[16]);
12925 digest
[3] = hex_to_uint (&input_buf
[24]);
12927 digest
[0] = byte_swap_32 (digest
[0]);
12928 digest
[1] = byte_swap_32 (digest
[1]);
12929 digest
[2] = byte_swap_32 (digest
[2]);
12930 digest
[3] = byte_swap_32 (digest
[3]);
12932 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12934 uint salt_len
= input_len
- 32 - 1;
12936 char *salt_buf
= input_buf
+ 32 + 1;
12938 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12940 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12942 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12944 salt
->salt_len
= salt_len
;
12946 return (PARSER_OK
);
12949 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12951 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12953 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
12957 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
12960 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12962 salt_t
*salt
= hash_buf
->salt
;
12964 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12965 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12966 digest
[2] = hex_to_uint (&input_buf
[16]);
12967 digest
[3] = hex_to_uint (&input_buf
[24]);
12968 digest
[4] = hex_to_uint (&input_buf
[32]);
12970 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12972 uint salt_len
= input_len
- 40 - 1;
12974 char *salt_buf
= input_buf
+ 40 + 1;
12976 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12978 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12980 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12982 salt
->salt_len
= salt_len
;
12984 return (PARSER_OK
);
12987 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12989 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12991 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
12995 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
12998 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13000 salt_t
*salt
= hash_buf
->salt
;
13002 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13003 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13004 digest
[2] = hex_to_uint (&input_buf
[16]);
13005 digest
[3] = hex_to_uint (&input_buf
[24]);
13006 digest
[4] = hex_to_uint (&input_buf
[32]);
13007 digest
[5] = hex_to_uint (&input_buf
[40]);
13008 digest
[6] = hex_to_uint (&input_buf
[48]);
13009 digest
[7] = hex_to_uint (&input_buf
[56]);
13011 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13013 uint salt_len
= input_len
- 64 - 1;
13015 char *salt_buf
= input_buf
+ 64 + 1;
13017 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13019 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13021 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13023 salt
->salt_len
= salt_len
;
13025 return (PARSER_OK
);
13028 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13030 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13032 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13036 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13039 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13041 salt_t
*salt
= hash_buf
->salt
;
13043 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13044 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13045 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13046 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13047 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13048 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13049 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13050 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13052 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13054 uint salt_len
= input_len
- 128 - 1;
13056 char *salt_buf
= input_buf
+ 128 + 1;
13058 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13062 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13064 salt
->salt_len
= salt_len
;
13066 return (PARSER_OK
);
13069 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13071 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13073 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13075 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13077 salt_t
*salt
= hash_buf
->salt
;
13079 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13085 char *user_pos
= input_buf
+ 10 + 1;
13087 char *realm_pos
= strchr (user_pos
, '$');
13089 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13091 uint user_len
= realm_pos
- user_pos
;
13093 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13097 char *salt_pos
= strchr (realm_pos
, '$');
13099 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13101 uint realm_len
= salt_pos
- realm_pos
;
13103 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13107 char *data_pos
= strchr (salt_pos
, '$');
13109 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13111 uint salt_len
= data_pos
- salt_pos
;
13113 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13117 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13119 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13125 memcpy (krb5pa
->user
, user_pos
, user_len
);
13126 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13127 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13129 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13131 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13133 const char p0
= data_pos
[i
+ 0];
13134 const char p1
= data_pos
[i
+ 1];
13136 *timestamp_ptr
++ = hex_convert (p1
) << 0
13137 | hex_convert (p0
) << 4;
13140 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13142 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13144 const char p0
= data_pos
[i
+ 0];
13145 const char p1
= data_pos
[i
+ 1];
13147 *checksum_ptr
++ = hex_convert (p1
) << 0
13148 | hex_convert (p0
) << 4;
13152 * copy some data to generic buffers to make sorting happy
13155 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13156 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13157 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13158 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13159 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13160 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13161 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13162 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13163 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13165 salt
->salt_len
= 36;
13167 digest
[0] = krb5pa
->checksum
[0];
13168 digest
[1] = krb5pa
->checksum
[1];
13169 digest
[2] = krb5pa
->checksum
[2];
13170 digest
[3] = krb5pa
->checksum
[3];
13172 return (PARSER_OK
);
13175 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13177 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13179 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13181 salt_t
*salt
= hash_buf
->salt
;
13187 char *salt_pos
= input_buf
;
13189 char *hash_pos
= strchr (salt_pos
, '$');
13191 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13193 uint salt_len
= hash_pos
- salt_pos
;
13195 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13199 uint hash_len
= input_len
- 1 - salt_len
;
13201 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13209 for (uint i
= 0; i
< salt_len
; i
++)
13211 if (salt_pos
[i
] == ' ') continue;
13216 // SAP user names cannot be longer than 12 characters
13217 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13219 // SAP user name cannot start with ! or ?
13220 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13226 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13228 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13230 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13232 salt
->salt_len
= salt_len
;
13234 digest
[0] = hex_to_uint (&hash_pos
[0]);
13235 digest
[1] = hex_to_uint (&hash_pos
[8]);
13239 digest
[0] = byte_swap_32 (digest
[0]);
13240 digest
[1] = byte_swap_32 (digest
[1]);
13242 return (PARSER_OK
);
13245 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13247 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13249 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13251 salt_t
*salt
= hash_buf
->salt
;
13257 char *salt_pos
= input_buf
;
13259 char *hash_pos
= strchr (salt_pos
, '$');
13261 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13263 uint salt_len
= hash_pos
- salt_pos
;
13265 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13269 uint hash_len
= input_len
- 1 - salt_len
;
13271 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13279 for (uint i
= 0; i
< salt_len
; i
++)
13281 if (salt_pos
[i
] == ' ') continue;
13286 // SAP user names cannot be longer than 12 characters
13287 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13289 // SAP user name cannot start with ! or ?
13290 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13296 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13298 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13302 salt
->salt_len
= salt_len
;
13304 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13305 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13306 digest
[2] = hex_to_uint (&hash_pos
[16]);
13307 digest
[3] = hex_to_uint (&hash_pos
[24]);
13308 digest
[4] = hex_to_uint (&hash_pos
[32]);
13310 return (PARSER_OK
);
13313 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13315 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13317 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13319 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13321 salt_t
*salt
= hash_buf
->salt
;
13323 char *iter_pos
= input_buf
+ 3;
13325 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13327 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13329 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13331 salt
->salt_iter
= salt_iter
;
13333 char *salt_pos
= iter_pos
+ 1;
13337 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13339 salt
->salt_len
= salt_len
;
13341 char *hash_pos
= salt_pos
+ salt_len
;
13343 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13347 char *tmp
= (char *) salt
->salt_buf_pc
;
13349 tmp
[0] = hash_pos
[42];
13353 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13354 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13355 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13356 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13362 return (PARSER_OK
);
13365 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13367 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13369 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13371 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13373 salt_t
*salt
= hash_buf
->salt
;
13375 char *salt_buf
= input_buf
+ 6;
13377 uint salt_len
= 16;
13379 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13381 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13383 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13385 salt
->salt_len
= salt_len
;
13387 char *hash_pos
= input_buf
+ 6 + 16;
13389 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13390 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13391 digest
[2] = hex_to_uint (&hash_pos
[16]);
13392 digest
[3] = hex_to_uint (&hash_pos
[24]);
13393 digest
[4] = hex_to_uint (&hash_pos
[32]);
13394 digest
[5] = hex_to_uint (&hash_pos
[40]);
13395 digest
[6] = hex_to_uint (&hash_pos
[48]);
13396 digest
[7] = hex_to_uint (&hash_pos
[56]);
13398 return (PARSER_OK
);
13401 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13403 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13405 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13407 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13408 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13412 return (PARSER_OK
);
13415 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13417 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13419 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13421 salt_t
*salt
= hash_buf
->salt
;
13423 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13425 char *saltbuf_pos
= input_buf
;
13427 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13429 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13431 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13433 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13434 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13436 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13440 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13442 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13444 char *salt_ptr
= (char *) saltbuf_pos
;
13445 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13450 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13452 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13455 rakp_ptr
[j
] = 0x80;
13457 rakp
->salt_len
= j
;
13459 for (i
= 0; i
< 64; i
++)
13461 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13464 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13465 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13466 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13467 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13468 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13469 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13470 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13471 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13473 salt
->salt_len
= 32; // muss min. 32 haben
13475 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13476 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13477 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13478 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13479 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13481 return (PARSER_OK
);
13484 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13486 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13488 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13490 salt_t
*salt
= hash_buf
->salt
;
13492 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13494 char *salt_pos
= input_buf
+ 1;
13496 memcpy (salt
->salt_buf
, salt_pos
, 8);
13498 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13499 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13501 salt
->salt_len
= 8;
13503 char *hash_pos
= salt_pos
+ 8;
13505 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13506 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13507 digest
[2] = hex_to_uint (&hash_pos
[16]);
13508 digest
[3] = hex_to_uint (&hash_pos
[24]);
13509 digest
[4] = hex_to_uint (&hash_pos
[32]);
13511 digest
[0] -= SHA1M_A
;
13512 digest
[1] -= SHA1M_B
;
13513 digest
[2] -= SHA1M_C
;
13514 digest
[3] -= SHA1M_D
;
13515 digest
[4] -= SHA1M_E
;
13517 return (PARSER_OK
);
13520 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13522 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13524 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13526 salt_t
*salt
= hash_buf
->salt
;
13528 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13529 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13530 digest
[2] = hex_to_uint (&input_buf
[16]);
13531 digest
[3] = hex_to_uint (&input_buf
[24]);
13533 digest
[0] = byte_swap_32 (digest
[0]);
13534 digest
[1] = byte_swap_32 (digest
[1]);
13535 digest
[2] = byte_swap_32 (digest
[2]);
13536 digest
[3] = byte_swap_32 (digest
[3]);
13538 digest
[0] -= MD5M_A
;
13539 digest
[1] -= MD5M_B
;
13540 digest
[2] -= MD5M_C
;
13541 digest
[3] -= MD5M_D
;
13543 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13545 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13547 uint32_t *salt_buf
= salt
->salt_buf
;
13549 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13550 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13551 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13552 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13554 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13555 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13556 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13557 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13559 salt
->salt_len
= 16 + 1;
13561 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13563 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13565 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13567 return (PARSER_OK
);
13570 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13572 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13574 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13576 salt_t
*salt
= hash_buf
->salt
;
13578 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13584 char *hashbuf_pos
= input_buf
;
13586 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13588 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13590 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13592 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13596 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13598 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13600 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13602 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13606 char *databuf_pos
= strchr (iteration_pos
, ':');
13608 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13610 const uint iteration_len
= databuf_pos
- iteration_pos
;
13612 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13613 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13615 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13617 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13618 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13624 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13625 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13626 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13627 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13628 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13629 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13630 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13631 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13635 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13637 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13639 const char p0
= saltbuf_pos
[i
+ 0];
13640 const char p1
= saltbuf_pos
[i
+ 1];
13642 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13643 | hex_convert (p0
) << 4;
13646 salt
->salt_buf
[4] = 0x01000000;
13647 salt
->salt_buf
[5] = 0x80;
13649 salt
->salt_len
= saltbuf_len
/ 2;
13653 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13657 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13659 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13661 const char p0
= databuf_pos
[i
+ 0];
13662 const char p1
= databuf_pos
[i
+ 1];
13664 *databuf_ptr
++ = hex_convert (p1
) << 0
13665 | hex_convert (p0
) << 4;
13668 *databuf_ptr
++ = 0x80;
13670 for (uint i
= 0; i
< 512; i
++)
13672 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13675 cloudkey
->data_len
= databuf_len
/ 2;
13677 return (PARSER_OK
);
13680 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13682 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13684 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13686 salt_t
*salt
= hash_buf
->salt
;
13692 char *hashbuf_pos
= input_buf
;
13694 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13696 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13698 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13700 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13704 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13706 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13708 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13710 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13712 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13716 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13718 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13720 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13722 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13724 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13728 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13730 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13731 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13733 // ok, the plan for this algorithm is the following:
13734 // we have 2 salts here, the domain-name and a random salt
13735 // while both are used in the initial transformation,
13736 // only the random salt is used in the following iterations
13737 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13738 // and one that includes only the real salt (stored into salt_buf[]).
13739 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13741 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13743 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13745 memcpy (digest
, tmp_buf
, 20);
13747 digest
[0] = byte_swap_32 (digest
[0]);
13748 digest
[1] = byte_swap_32 (digest
[1]);
13749 digest
[2] = byte_swap_32 (digest
[2]);
13750 digest
[3] = byte_swap_32 (digest
[3]);
13751 digest
[4] = byte_swap_32 (digest
[4]);
13755 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13757 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13759 char *len_ptr
= NULL
;
13761 for (uint i
= 0; i
< domainbuf_len
; i
++)
13763 if (salt_buf_pc_ptr
[i
] == '.')
13765 len_ptr
= &salt_buf_pc_ptr
[i
];
13775 salt
->salt_buf_pc
[7] = domainbuf_len
;
13779 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13781 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13783 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13785 salt
->salt_len
= salt_len
;
13789 salt
->salt_iter
= atoi (iteration_pos
);
13791 return (PARSER_OK
);
13794 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13796 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13798 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13800 salt_t
*salt
= hash_buf
->salt
;
13802 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13803 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13804 digest
[2] = hex_to_uint (&input_buf
[16]);
13805 digest
[3] = hex_to_uint (&input_buf
[24]);
13806 digest
[4] = hex_to_uint (&input_buf
[32]);
13808 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13810 uint salt_len
= input_len
- 40 - 1;
13812 char *salt_buf
= input_buf
+ 40 + 1;
13814 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13816 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13818 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13820 salt
->salt_len
= salt_len
;
13822 return (PARSER_OK
);
13825 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13827 const uint8_t ascii_to_ebcdic
[] =
13829 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13830 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13831 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13832 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13833 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13834 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13835 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13836 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13837 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13838 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13839 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13840 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13841 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13842 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13843 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13844 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13847 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13849 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13851 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13853 salt_t
*salt
= hash_buf
->salt
;
13855 char *salt_pos
= input_buf
+ 6 + 1;
13857 char *digest_pos
= strchr (salt_pos
, '*');
13859 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13861 uint salt_len
= digest_pos
- salt_pos
;
13863 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13865 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13867 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13871 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13872 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13874 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13876 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13878 salt
->salt_len
= salt_len
;
13880 for (uint i
= 0; i
< salt_len
; i
++)
13882 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13884 for (uint i
= salt_len
; i
< 8; i
++)
13886 salt_buf_pc_ptr
[i
] = 0x40;
13891 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13893 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13894 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13896 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13897 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13899 digest
[0] = byte_swap_32 (digest
[0]);
13900 digest
[1] = byte_swap_32 (digest
[1]);
13902 IP (digest
[0], digest
[1], tt
);
13904 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13905 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13909 return (PARSER_OK
);
13912 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13914 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13916 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13918 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13919 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13920 digest
[2] = hex_to_uint (&input_buf
[16]);
13921 digest
[3] = hex_to_uint (&input_buf
[24]);
13923 digest
[0] = byte_swap_32 (digest
[0]);
13924 digest
[1] = byte_swap_32 (digest
[1]);
13925 digest
[2] = byte_swap_32 (digest
[2]);
13926 digest
[3] = byte_swap_32 (digest
[3]);
13928 return (PARSER_OK
);
13931 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13933 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13935 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13937 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13939 salt_t
*salt
= hash_buf
->salt
;
13943 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13945 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13947 tmp_buf
[3] += -4; // dont ask!
13949 memcpy (salt
->salt_buf
, tmp_buf
, 5);
13951 salt
->salt_len
= 5;
13953 memcpy (digest
, tmp_buf
+ 5, 9);
13955 // yes, only 9 byte are needed to crack, but 10 to display
13957 salt
->salt_buf_pc
[7] = input_buf
[20];
13959 return (PARSER_OK
);
13962 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13964 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
13966 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13968 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13970 salt_t
*salt
= hash_buf
->salt
;
13974 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13976 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13978 tmp_buf
[3] += -4; // dont ask!
13982 memcpy (salt
->salt_buf
, tmp_buf
, 16);
13984 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)
13988 char tmp_iter_buf
[11];
13990 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
13992 tmp_iter_buf
[10] = 0;
13994 salt
->salt_iter
= atoi (tmp_iter_buf
);
13996 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
13998 return (PARSER_SALT_ITERATION
);
14001 salt
->salt_iter
--; // first round in init
14003 // 2 additional bytes for display only
14005 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14006 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14010 memcpy (digest
, tmp_buf
+ 28, 8);
14012 digest
[0] = byte_swap_32 (digest
[0]);
14013 digest
[1] = byte_swap_32 (digest
[1]);
14017 return (PARSER_OK
);
14020 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14022 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14024 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14026 salt_t
*salt
= hash_buf
->salt
;
14028 char *salt_buf_pos
= input_buf
;
14030 char *hash_buf_pos
= salt_buf_pos
+ 6;
14032 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14033 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14034 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14035 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14036 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14037 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14038 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14039 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14041 digest
[0] -= SHA256M_A
;
14042 digest
[1] -= SHA256M_B
;
14043 digest
[2] -= SHA256M_C
;
14044 digest
[3] -= SHA256M_D
;
14045 digest
[4] -= SHA256M_E
;
14046 digest
[5] -= SHA256M_F
;
14047 digest
[6] -= SHA256M_G
;
14048 digest
[7] -= SHA256M_H
;
14050 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14052 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14054 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14056 salt
->salt_len
= salt_len
;
14058 return (PARSER_OK
);
14061 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14063 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14065 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14067 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14069 salt_t
*salt
= hash_buf
->salt
;
14071 char *salt_buf
= input_buf
+ 6;
14073 char *digest_buf
= strchr (salt_buf
, '$');
14075 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14077 uint salt_len
= digest_buf
- salt_buf
;
14079 digest_buf
++; // skip the '$' symbol
14081 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14083 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14085 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14087 salt
->salt_len
= salt_len
;
14089 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14090 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14091 digest
[2] = hex_to_uint (&digest_buf
[16]);
14092 digest
[3] = hex_to_uint (&digest_buf
[24]);
14094 digest
[0] = byte_swap_32 (digest
[0]);
14095 digest
[1] = byte_swap_32 (digest
[1]);
14096 digest
[2] = byte_swap_32 (digest
[2]);
14097 digest
[3] = byte_swap_32 (digest
[3]);
14099 digest
[0] -= MD5M_A
;
14100 digest
[1] -= MD5M_B
;
14101 digest
[2] -= MD5M_C
;
14102 digest
[3] -= MD5M_D
;
14104 return (PARSER_OK
);
14107 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14109 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14111 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14113 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14115 salt_t
*salt
= hash_buf
->salt
;
14117 char *salt_buf
= input_buf
+ 3;
14119 char *digest_buf
= strchr (salt_buf
, '$');
14121 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14123 uint salt_len
= digest_buf
- salt_buf
;
14125 digest_buf
++; // skip the '$' symbol
14127 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14129 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14131 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14133 salt_buf_ptr
[salt_len
] = 0x2d;
14135 salt
->salt_len
= salt_len
+ 1;
14137 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14138 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14139 digest
[2] = hex_to_uint (&digest_buf
[16]);
14140 digest
[3] = hex_to_uint (&digest_buf
[24]);
14142 digest
[0] = byte_swap_32 (digest
[0]);
14143 digest
[1] = byte_swap_32 (digest
[1]);
14144 digest
[2] = byte_swap_32 (digest
[2]);
14145 digest
[3] = byte_swap_32 (digest
[3]);
14147 digest
[0] -= MD5M_A
;
14148 digest
[1] -= MD5M_B
;
14149 digest
[2] -= MD5M_C
;
14150 digest
[3] -= MD5M_D
;
14152 return (PARSER_OK
);
14155 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14157 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14159 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14163 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14165 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14167 memcpy (digest
, tmp_buf
, 20);
14169 digest
[0] = byte_swap_32 (digest
[0]);
14170 digest
[1] = byte_swap_32 (digest
[1]);
14171 digest
[2] = byte_swap_32 (digest
[2]);
14172 digest
[3] = byte_swap_32 (digest
[3]);
14173 digest
[4] = byte_swap_32 (digest
[4]);
14175 digest
[0] -= SHA1M_A
;
14176 digest
[1] -= SHA1M_B
;
14177 digest
[2] -= SHA1M_C
;
14178 digest
[3] -= SHA1M_D
;
14179 digest
[4] -= SHA1M_E
;
14181 return (PARSER_OK
);
14184 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14186 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14188 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14190 salt_t
*salt
= hash_buf
->salt
;
14192 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14193 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14194 digest
[2] = hex_to_uint (&input_buf
[16]);
14195 digest
[3] = hex_to_uint (&input_buf
[24]);
14197 digest
[0] = byte_swap_32 (digest
[0]);
14198 digest
[1] = byte_swap_32 (digest
[1]);
14199 digest
[2] = byte_swap_32 (digest
[2]);
14200 digest
[3] = byte_swap_32 (digest
[3]);
14202 digest
[0] -= MD5M_A
;
14203 digest
[1] -= MD5M_B
;
14204 digest
[2] -= MD5M_C
;
14205 digest
[3] -= MD5M_D
;
14207 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14209 uint salt_len
= input_len
- 32 - 1;
14211 char *salt_buf
= input_buf
+ 32 + 1;
14213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14215 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14217 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14220 * add static "salt" part
14223 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14227 salt
->salt_len
= salt_len
;
14229 return (PARSER_OK
);
14232 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14234 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14236 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14238 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14240 salt_t
*salt
= hash_buf
->salt
;
14242 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14248 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14250 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14252 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14254 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14256 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14260 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14262 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14264 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14266 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14270 char *keybuf_pos
= strchr (keylen_pos
, '$');
14272 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14274 uint keylen_len
= keybuf_pos
- keylen_pos
;
14276 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14280 char *databuf_pos
= strchr (keybuf_pos
, '$');
14282 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14284 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14286 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14290 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14292 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14298 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14299 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14300 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14301 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14303 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14304 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14305 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14306 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14308 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14309 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14310 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14311 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14313 salt
->salt_len
= 16;
14314 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14316 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14318 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14321 return (PARSER_OK
);
14324 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14326 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14328 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14330 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14332 salt_t
*salt
= hash_buf
->salt
;
14338 // first is the N salt parameter
14340 char *N_pos
= input_buf
+ 6;
14342 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14346 salt
->scrypt_N
= atoi (N_pos
);
14350 char *r_pos
= strchr (N_pos
, ':');
14352 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14356 salt
->scrypt_r
= atoi (r_pos
);
14360 char *p_pos
= strchr (r_pos
, ':');
14362 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14366 salt
->scrypt_p
= atoi (p_pos
);
14370 char *saltbuf_pos
= strchr (p_pos
, ':');
14372 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14376 char *hash_pos
= strchr (saltbuf_pos
, ':');
14378 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14386 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14388 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14390 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14392 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14394 salt
->salt_len
= tmp_len
;
14395 salt
->salt_iter
= 1;
14397 // digest - base64 decode
14399 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14401 tmp_len
= input_len
- (hash_pos
- input_buf
);
14403 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14405 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14407 memcpy (digest
, tmp_buf
, 32);
14409 return (PARSER_OK
);
14412 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14414 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14416 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14418 salt_t
*salt
= hash_buf
->salt
;
14424 char decrypted
[76]; // iv + hash
14426 juniper_decrypt_hash (input_buf
, decrypted
);
14428 char *md5crypt_hash
= decrypted
+ 12;
14430 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14432 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14434 char *salt_pos
= md5crypt_hash
+ 3;
14436 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14438 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14440 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14444 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14446 return (PARSER_OK
);
14449 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14451 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14453 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14455 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14457 salt_t
*salt
= hash_buf
->salt
;
14459 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14465 // first is *raw* salt
14467 char *salt_pos
= input_buf
+ 3;
14469 char *hash_pos
= strchr (salt_pos
, '$');
14471 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14473 uint salt_len
= hash_pos
- salt_pos
;
14475 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14479 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14481 memcpy (salt_buf_ptr
, salt_pos
, 14);
14483 salt_buf_ptr
[17] = 0x01;
14484 salt_buf_ptr
[18] = 0x80;
14486 // add some stuff to normal salt to make sorted happy
14488 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14489 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14490 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14491 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14493 salt
->salt_len
= salt_len
;
14494 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14496 // base64 decode hash
14500 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14502 uint hash_len
= input_len
- 3 - salt_len
- 1;
14504 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14506 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14508 memcpy (digest
, tmp_buf
, 32);
14510 digest
[0] = byte_swap_32 (digest
[0]);
14511 digest
[1] = byte_swap_32 (digest
[1]);
14512 digest
[2] = byte_swap_32 (digest
[2]);
14513 digest
[3] = byte_swap_32 (digest
[3]);
14514 digest
[4] = byte_swap_32 (digest
[4]);
14515 digest
[5] = byte_swap_32 (digest
[5]);
14516 digest
[6] = byte_swap_32 (digest
[6]);
14517 digest
[7] = byte_swap_32 (digest
[7]);
14519 return (PARSER_OK
);
14522 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14524 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14526 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14528 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14530 salt_t
*salt
= hash_buf
->salt
;
14536 // first is *raw* salt
14538 char *salt_pos
= input_buf
+ 3;
14540 char *hash_pos
= strchr (salt_pos
, '$');
14542 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14544 uint salt_len
= hash_pos
- salt_pos
;
14546 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14548 salt
->salt_len
= salt_len
;
14551 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14553 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14554 salt_buf_ptr
[salt_len
] = 0;
14556 // base64 decode hash
14560 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14562 uint hash_len
= input_len
- 3 - salt_len
- 1;
14564 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14566 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14568 memcpy (digest
, tmp_buf
, 32);
14571 salt
->scrypt_N
= 16384;
14572 salt
->scrypt_r
= 1;
14573 salt
->scrypt_p
= 1;
14574 salt
->salt_iter
= 1;
14576 return (PARSER_OK
);
14579 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14581 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14583 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14585 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14587 salt_t
*salt
= hash_buf
->salt
;
14589 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14595 char *version_pos
= input_buf
+ 8 + 1;
14597 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14599 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14601 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14603 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14605 verifierHashSize_pos
++;
14607 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14609 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14611 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14613 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14617 char *saltSize_pos
= strchr (keySize_pos
, '*');
14619 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14621 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14623 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14627 char *osalt_pos
= strchr (saltSize_pos
, '*');
14629 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14631 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14633 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14637 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14639 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14641 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14643 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14645 encryptedVerifier_pos
++;
14647 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14649 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14651 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14653 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14655 encryptedVerifierHash_pos
++;
14657 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;
14659 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14661 const uint version
= atoi (version_pos
);
14663 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14665 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14667 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14669 const uint keySize
= atoi (keySize_pos
);
14671 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14673 office2007
->keySize
= keySize
;
14675 const uint saltSize
= atoi (saltSize_pos
);
14677 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14683 salt
->salt_len
= 16;
14684 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14686 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14687 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14688 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14689 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14695 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14696 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14697 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14698 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14700 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14701 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14702 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14703 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14704 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14710 digest
[0] = office2007
->encryptedVerifierHash
[0];
14711 digest
[1] = office2007
->encryptedVerifierHash
[1];
14712 digest
[2] = office2007
->encryptedVerifierHash
[2];
14713 digest
[3] = office2007
->encryptedVerifierHash
[3];
14715 return (PARSER_OK
);
14718 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14720 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14722 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14724 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14726 salt_t
*salt
= hash_buf
->salt
;
14728 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14734 char *version_pos
= input_buf
+ 8 + 1;
14736 char *spinCount_pos
= strchr (version_pos
, '*');
14738 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14740 uint32_t version_len
= spinCount_pos
- version_pos
;
14742 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14746 char *keySize_pos
= strchr (spinCount_pos
, '*');
14748 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14750 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14752 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14756 char *saltSize_pos
= strchr (keySize_pos
, '*');
14758 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14760 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14762 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14766 char *osalt_pos
= strchr (saltSize_pos
, '*');
14768 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14770 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14772 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14776 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14778 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14780 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14782 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14784 encryptedVerifier_pos
++;
14786 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14788 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14790 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14792 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14794 encryptedVerifierHash_pos
++;
14796 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;
14798 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14800 const uint version
= atoi (version_pos
);
14802 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14804 const uint spinCount
= atoi (spinCount_pos
);
14806 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14808 const uint keySize
= atoi (keySize_pos
);
14810 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14812 const uint saltSize
= atoi (saltSize_pos
);
14814 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14820 salt
->salt_len
= 16;
14821 salt
->salt_iter
= spinCount
;
14823 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14824 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14825 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14826 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14832 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14833 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14834 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14835 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14837 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14838 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14839 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14840 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14841 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14842 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14843 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14844 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14850 digest
[0] = office2010
->encryptedVerifierHash
[0];
14851 digest
[1] = office2010
->encryptedVerifierHash
[1];
14852 digest
[2] = office2010
->encryptedVerifierHash
[2];
14853 digest
[3] = office2010
->encryptedVerifierHash
[3];
14855 return (PARSER_OK
);
14858 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14860 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14862 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14864 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14866 salt_t
*salt
= hash_buf
->salt
;
14868 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14874 char *version_pos
= input_buf
+ 8 + 1;
14876 char *spinCount_pos
= strchr (version_pos
, '*');
14878 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14880 uint32_t version_len
= spinCount_pos
- version_pos
;
14882 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14886 char *keySize_pos
= strchr (spinCount_pos
, '*');
14888 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14890 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14892 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14896 char *saltSize_pos
= strchr (keySize_pos
, '*');
14898 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14900 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14902 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14906 char *osalt_pos
= strchr (saltSize_pos
, '*');
14908 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14910 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14912 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14916 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14918 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14920 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14922 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14924 encryptedVerifier_pos
++;
14926 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14928 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14930 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14932 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14934 encryptedVerifierHash_pos
++;
14936 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;
14938 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14940 const uint version
= atoi (version_pos
);
14942 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14944 const uint spinCount
= atoi (spinCount_pos
);
14946 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14948 const uint keySize
= atoi (keySize_pos
);
14950 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
14952 const uint saltSize
= atoi (saltSize_pos
);
14954 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14960 salt
->salt_len
= 16;
14961 salt
->salt_iter
= spinCount
;
14963 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14964 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14965 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14966 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14972 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14973 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14974 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14975 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14977 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14978 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14979 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14980 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14981 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14982 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14983 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14984 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14990 digest
[0] = office2013
->encryptedVerifierHash
[0];
14991 digest
[1] = office2013
->encryptedVerifierHash
[1];
14992 digest
[2] = office2013
->encryptedVerifierHash
[2];
14993 digest
[3] = office2013
->encryptedVerifierHash
[3];
14995 return (PARSER_OK
);
14998 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15000 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15002 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15004 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15006 salt_t
*salt
= hash_buf
->salt
;
15008 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15014 char *version_pos
= input_buf
+ 11;
15016 char *osalt_pos
= strchr (version_pos
, '*');
15018 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15020 uint32_t version_len
= osalt_pos
- version_pos
;
15022 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15026 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15028 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15030 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15032 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15034 encryptedVerifier_pos
++;
15036 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15038 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15040 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15042 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15044 encryptedVerifierHash_pos
++;
15046 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15048 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15050 const uint version
= *version_pos
- 0x30;
15052 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15058 oldoffice01
->version
= version
;
15060 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15061 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15062 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15063 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15065 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15066 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15067 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15068 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15070 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15071 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15072 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15073 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15075 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15076 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15077 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15078 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15084 salt
->salt_len
= 16;
15086 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15087 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15088 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15089 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15091 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15092 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15093 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15094 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15096 // this is a workaround as office produces multiple documents with the same salt
15098 salt
->salt_len
+= 32;
15100 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15101 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15102 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15103 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15104 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15105 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15106 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15107 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15113 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15114 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15115 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15116 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15118 return (PARSER_OK
);
15121 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15123 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15126 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15128 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15130 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15132 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15134 salt_t
*salt
= hash_buf
->salt
;
15136 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15142 char *version_pos
= input_buf
+ 11;
15144 char *osalt_pos
= strchr (version_pos
, '*');
15146 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15148 uint32_t version_len
= osalt_pos
- version_pos
;
15150 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15154 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15156 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15158 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15160 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15162 encryptedVerifier_pos
++;
15164 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15166 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15168 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15170 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15172 encryptedVerifierHash_pos
++;
15174 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15176 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15178 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15180 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15184 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15186 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15188 const uint version
= *version_pos
- 0x30;
15190 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15196 oldoffice01
->version
= version
;
15198 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15199 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15200 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15201 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15203 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15204 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15205 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15206 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15208 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15209 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15210 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15211 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15213 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15214 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15215 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15216 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15218 oldoffice01
->rc4key
[1] = 0;
15219 oldoffice01
->rc4key
[0] = 0;
15221 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15222 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15223 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15224 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15225 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15226 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15227 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15228 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15229 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15230 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15232 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15233 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15239 salt
->salt_len
= 16;
15241 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15242 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15243 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15244 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15246 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15247 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15248 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15249 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15251 // this is a workaround as office produces multiple documents with the same salt
15253 salt
->salt_len
+= 32;
15255 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15256 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15257 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15258 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15259 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15260 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15261 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15262 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15268 digest
[0] = oldoffice01
->rc4key
[0];
15269 digest
[1] = oldoffice01
->rc4key
[1];
15273 return (PARSER_OK
);
15276 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15278 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15280 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15282 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15284 salt_t
*salt
= hash_buf
->salt
;
15286 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15292 char *version_pos
= input_buf
+ 11;
15294 char *osalt_pos
= strchr (version_pos
, '*');
15296 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15298 uint32_t version_len
= osalt_pos
- version_pos
;
15300 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15304 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15306 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15308 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15310 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15312 encryptedVerifier_pos
++;
15314 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15316 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15318 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15320 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15322 encryptedVerifierHash_pos
++;
15324 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15326 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15328 const uint version
= *version_pos
- 0x30;
15330 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15336 oldoffice34
->version
= version
;
15338 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15339 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15340 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15341 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15343 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15344 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15345 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15346 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15348 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15349 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15350 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15351 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15352 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15354 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15355 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15356 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15357 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15358 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15364 salt
->salt_len
= 16;
15366 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15367 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15368 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15369 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15371 // this is a workaround as office produces multiple documents with the same salt
15373 salt
->salt_len
+= 32;
15375 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15376 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15377 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15378 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15379 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15380 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15381 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15382 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15388 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15389 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15390 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15391 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15393 return (PARSER_OK
);
15396 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15398 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15400 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15403 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15405 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15407 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15409 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15411 salt_t
*salt
= hash_buf
->salt
;
15413 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15419 char *version_pos
= input_buf
+ 11;
15421 char *osalt_pos
= strchr (version_pos
, '*');
15423 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15425 uint32_t version_len
= osalt_pos
- version_pos
;
15427 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15431 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15433 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15435 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15437 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15439 encryptedVerifier_pos
++;
15441 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15443 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15445 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15447 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15449 encryptedVerifierHash_pos
++;
15451 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15453 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15455 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15457 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15461 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15463 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15465 const uint version
= *version_pos
- 0x30;
15467 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15473 oldoffice34
->version
= version
;
15475 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15476 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15477 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15478 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15480 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15481 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15482 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15483 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15485 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15486 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15487 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15488 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15489 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15491 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15492 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15493 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15494 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15495 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15497 oldoffice34
->rc4key
[1] = 0;
15498 oldoffice34
->rc4key
[0] = 0;
15500 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15501 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15502 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15503 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15504 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15505 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15506 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15507 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15508 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15509 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15511 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15512 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15518 salt
->salt_len
= 16;
15520 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15521 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15522 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15523 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15525 // this is a workaround as office produces multiple documents with the same salt
15527 salt
->salt_len
+= 32;
15529 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15530 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15531 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15532 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15533 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15534 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15535 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15536 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15542 digest
[0] = oldoffice34
->rc4key
[0];
15543 digest
[1] = oldoffice34
->rc4key
[1];
15547 return (PARSER_OK
);
15550 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15552 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15554 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15556 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15557 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15558 digest
[2] = hex_to_uint (&input_buf
[16]);
15559 digest
[3] = hex_to_uint (&input_buf
[24]);
15561 digest
[0] = byte_swap_32 (digest
[0]);
15562 digest
[1] = byte_swap_32 (digest
[1]);
15563 digest
[2] = byte_swap_32 (digest
[2]);
15564 digest
[3] = byte_swap_32 (digest
[3]);
15566 return (PARSER_OK
);
15569 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15571 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15573 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15575 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15577 salt_t
*salt
= hash_buf
->salt
;
15579 char *signature_pos
= input_buf
;
15581 char *salt_pos
= strchr (signature_pos
, '$');
15583 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15585 uint32_t signature_len
= salt_pos
- signature_pos
;
15587 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15591 char *hash_pos
= strchr (salt_pos
, '$');
15593 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15595 uint32_t salt_len
= hash_pos
- salt_pos
;
15597 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15601 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15603 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15605 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15606 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15607 digest
[2] = hex_to_uint (&hash_pos
[16]);
15608 digest
[3] = hex_to_uint (&hash_pos
[24]);
15609 digest
[4] = hex_to_uint (&hash_pos
[32]);
15611 digest
[0] -= SHA1M_A
;
15612 digest
[1] -= SHA1M_B
;
15613 digest
[2] -= SHA1M_C
;
15614 digest
[3] -= SHA1M_D
;
15615 digest
[4] -= SHA1M_E
;
15617 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15619 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15621 salt
->salt_len
= salt_len
;
15623 return (PARSER_OK
);
15626 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15628 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15630 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15632 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15634 salt_t
*salt
= hash_buf
->salt
;
15636 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15642 char *iter_pos
= input_buf
+ 14;
15644 const int iter
= atoi (iter_pos
);
15646 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15648 salt
->salt_iter
= iter
- 1;
15650 char *salt_pos
= strchr (iter_pos
, '$');
15652 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15656 char *hash_pos
= strchr (salt_pos
, '$');
15658 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15660 const uint salt_len
= hash_pos
- salt_pos
;
15664 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15666 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15668 salt
->salt_len
= salt_len
;
15670 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15671 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15673 // add some stuff to normal salt to make sorted happy
15675 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15676 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15677 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15678 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15679 salt
->salt_buf
[4] = salt
->salt_iter
;
15681 // base64 decode hash
15685 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15687 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15689 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15691 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15693 memcpy (digest
, tmp_buf
, 32);
15695 digest
[0] = byte_swap_32 (digest
[0]);
15696 digest
[1] = byte_swap_32 (digest
[1]);
15697 digest
[2] = byte_swap_32 (digest
[2]);
15698 digest
[3] = byte_swap_32 (digest
[3]);
15699 digest
[4] = byte_swap_32 (digest
[4]);
15700 digest
[5] = byte_swap_32 (digest
[5]);
15701 digest
[6] = byte_swap_32 (digest
[6]);
15702 digest
[7] = byte_swap_32 (digest
[7]);
15704 return (PARSER_OK
);
15707 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15709 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15711 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15713 salt_t
*salt
= hash_buf
->salt
;
15715 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15716 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15720 digest
[0] = byte_swap_32 (digest
[0]);
15721 digest
[1] = byte_swap_32 (digest
[1]);
15723 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15724 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15725 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15727 char iter_c
= input_buf
[17];
15728 char iter_d
= input_buf
[19];
15730 // atm only defaults, let's see if there's more request
15731 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15732 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15734 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15736 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15737 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15738 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15739 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15741 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15742 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15743 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15744 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15746 salt
->salt_len
= 16;
15748 return (PARSER_OK
);
15751 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15753 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15755 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15757 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15759 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15761 salt_t
*salt
= hash_buf
->salt
;
15763 char *salt_pos
= input_buf
+ 10;
15765 char *hash_pos
= strchr (salt_pos
, '$');
15767 uint salt_len
= hash_pos
- salt_pos
;
15769 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15773 uint hash_len
= input_len
- 10 - salt_len
- 1;
15775 // base64 decode salt
15779 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15781 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15783 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15785 tmp_buf
[salt_len
] = 0x80;
15787 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15789 salt
->salt_len
= salt_len
;
15791 // base64 decode salt
15793 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15795 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15797 uint user_len
= hash_len
- 32;
15799 char *tmp_hash
= tmp_buf
+ user_len
;
15801 user_len
--; // skip the trailing space
15803 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15804 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15805 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15806 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15808 digest
[0] = byte_swap_32 (digest
[0]);
15809 digest
[1] = byte_swap_32 (digest
[1]);
15810 digest
[2] = byte_swap_32 (digest
[2]);
15811 digest
[3] = byte_swap_32 (digest
[3]);
15813 // store username for host only (output hash if cracked)
15815 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15816 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15818 return (PARSER_OK
);
15821 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15823 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15825 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15827 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15829 salt_t
*salt
= hash_buf
->salt
;
15831 char *iter_pos
= input_buf
+ 10;
15833 uint32_t iter
= atoi (iter_pos
);
15837 return (PARSER_SALT_ITERATION
);
15840 iter
--; // first iteration is special
15842 salt
->salt_iter
= iter
;
15844 char *base64_pos
= strchr (iter_pos
, '}');
15846 if (base64_pos
== NULL
)
15848 return (PARSER_SIGNATURE_UNMATCHED
);
15853 // base64 decode salt
15855 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15859 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15861 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15863 if (decoded_len
< 24)
15865 return (PARSER_SALT_LENGTH
);
15870 uint salt_len
= decoded_len
- 20;
15872 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15873 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15875 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15877 salt
->salt_len
= salt_len
;
15881 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15883 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15884 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15885 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15886 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15887 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15889 return (PARSER_OK
);
15892 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15894 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15896 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15898 salt_t
*salt
= hash_buf
->salt
;
15900 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15901 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15902 digest
[2] = hex_to_uint (&input_buf
[16]);
15903 digest
[3] = hex_to_uint (&input_buf
[24]);
15904 digest
[4] = hex_to_uint (&input_buf
[32]);
15906 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15908 uint salt_len
= input_len
- 40 - 1;
15910 char *salt_buf
= input_buf
+ 40 + 1;
15912 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15914 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15916 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15918 salt
->salt_len
= salt_len
;
15920 return (PARSER_OK
);
15923 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15925 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15927 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15929 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15931 salt_t
*salt
= hash_buf
->salt
;
15933 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15939 char *V_pos
= input_buf
+ 5;
15941 char *R_pos
= strchr (V_pos
, '*');
15943 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15945 uint32_t V_len
= R_pos
- V_pos
;
15949 char *bits_pos
= strchr (R_pos
, '*');
15951 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15953 uint32_t R_len
= bits_pos
- R_pos
;
15957 char *P_pos
= strchr (bits_pos
, '*');
15959 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15961 uint32_t bits_len
= P_pos
- bits_pos
;
15965 char *enc_md_pos
= strchr (P_pos
, '*');
15967 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15969 uint32_t P_len
= enc_md_pos
- P_pos
;
15973 char *id_len_pos
= strchr (enc_md_pos
, '*');
15975 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15977 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
15981 char *id_buf_pos
= strchr (id_len_pos
, '*');
15983 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15985 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
15989 char *u_len_pos
= strchr (id_buf_pos
, '*');
15991 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15993 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
15995 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
15999 char *u_buf_pos
= strchr (u_len_pos
, '*');
16001 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16003 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16007 char *o_len_pos
= strchr (u_buf_pos
, '*');
16009 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16011 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16013 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16017 char *o_buf_pos
= strchr (o_len_pos
, '*');
16019 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16021 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16025 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;
16027 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16031 const int V
= atoi (V_pos
);
16032 const int R
= atoi (R_pos
);
16033 const int P
= atoi (P_pos
);
16035 if (V
!= 1) return (PARSER_SALT_VALUE
);
16036 if (R
!= 2) return (PARSER_SALT_VALUE
);
16038 const int enc_md
= atoi (enc_md_pos
);
16040 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16042 const int id_len
= atoi (id_len_pos
);
16043 const int u_len
= atoi (u_len_pos
);
16044 const int o_len
= atoi (o_len_pos
);
16046 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16047 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16048 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16050 const int bits
= atoi (bits_pos
);
16052 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16054 // copy data to esalt
16060 pdf
->enc_md
= enc_md
;
16062 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16063 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16064 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16065 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16066 pdf
->id_len
= id_len
;
16068 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16069 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16070 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16071 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16072 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16073 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16074 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16075 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16076 pdf
->u_len
= u_len
;
16078 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16079 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16080 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16081 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16082 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16083 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16084 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16085 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16086 pdf
->o_len
= o_len
;
16088 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16089 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16090 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16091 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16093 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16094 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16095 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16096 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16097 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16098 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16099 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16100 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16102 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16103 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16104 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16105 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16106 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16107 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16108 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16109 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16111 // we use ID for salt, maybe needs to change, we will see...
16113 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16114 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16115 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16116 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16117 salt
->salt_len
= pdf
->id_len
;
16119 digest
[0] = pdf
->u_buf
[0];
16120 digest
[1] = pdf
->u_buf
[1];
16121 digest
[2] = pdf
->u_buf
[2];
16122 digest
[3] = pdf
->u_buf
[3];
16124 return (PARSER_OK
);
16127 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16129 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16132 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16134 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16136 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16138 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16140 salt_t
*salt
= hash_buf
->salt
;
16142 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16148 char *V_pos
= input_buf
+ 5;
16150 char *R_pos
= strchr (V_pos
, '*');
16152 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16154 uint32_t V_len
= R_pos
- V_pos
;
16158 char *bits_pos
= strchr (R_pos
, '*');
16160 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16162 uint32_t R_len
= bits_pos
- R_pos
;
16166 char *P_pos
= strchr (bits_pos
, '*');
16168 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16170 uint32_t bits_len
= P_pos
- bits_pos
;
16174 char *enc_md_pos
= strchr (P_pos
, '*');
16176 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16178 uint32_t P_len
= enc_md_pos
- P_pos
;
16182 char *id_len_pos
= strchr (enc_md_pos
, '*');
16184 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16186 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16190 char *id_buf_pos
= strchr (id_len_pos
, '*');
16192 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16194 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16198 char *u_len_pos
= strchr (id_buf_pos
, '*');
16200 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16202 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16204 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16208 char *u_buf_pos
= strchr (u_len_pos
, '*');
16210 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16212 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16216 char *o_len_pos
= strchr (u_buf_pos
, '*');
16218 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16220 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16222 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16226 char *o_buf_pos
= strchr (o_len_pos
, '*');
16228 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16230 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16234 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16236 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16238 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16240 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16244 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;
16246 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16250 const int V
= atoi (V_pos
);
16251 const int R
= atoi (R_pos
);
16252 const int P
= atoi (P_pos
);
16254 if (V
!= 1) return (PARSER_SALT_VALUE
);
16255 if (R
!= 2) return (PARSER_SALT_VALUE
);
16257 const int enc_md
= atoi (enc_md_pos
);
16259 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16261 const int id_len
= atoi (id_len_pos
);
16262 const int u_len
= atoi (u_len_pos
);
16263 const int o_len
= atoi (o_len_pos
);
16265 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16266 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16267 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16269 const int bits
= atoi (bits_pos
);
16271 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16273 // copy data to esalt
16279 pdf
->enc_md
= enc_md
;
16281 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16282 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16283 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16284 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16285 pdf
->id_len
= id_len
;
16287 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16288 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16289 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16290 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16291 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16292 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16293 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16294 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16295 pdf
->u_len
= u_len
;
16297 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16298 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16299 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16300 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16301 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16302 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16303 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16304 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16305 pdf
->o_len
= o_len
;
16307 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16308 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16309 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16310 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16312 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16313 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16314 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16315 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16316 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16317 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16318 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16319 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16321 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16322 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16323 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16324 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16325 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16326 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16327 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16328 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16330 pdf
->rc4key
[1] = 0;
16331 pdf
->rc4key
[0] = 0;
16333 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16334 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16335 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16336 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16337 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16338 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16339 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16340 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16341 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16342 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16344 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16345 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16347 // we use ID for salt, maybe needs to change, we will see...
16349 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16350 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16351 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16352 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16353 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16354 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16355 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16356 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16357 salt
->salt_len
= pdf
->id_len
+ 16;
16359 digest
[0] = pdf
->rc4key
[0];
16360 digest
[1] = pdf
->rc4key
[1];
16364 return (PARSER_OK
);
16367 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16369 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16371 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16373 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16375 salt_t
*salt
= hash_buf
->salt
;
16377 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16383 char *V_pos
= input_buf
+ 5;
16385 char *R_pos
= strchr (V_pos
, '*');
16387 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16389 uint32_t V_len
= R_pos
- V_pos
;
16393 char *bits_pos
= strchr (R_pos
, '*');
16395 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16397 uint32_t R_len
= bits_pos
- R_pos
;
16401 char *P_pos
= strchr (bits_pos
, '*');
16403 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16405 uint32_t bits_len
= P_pos
- bits_pos
;
16409 char *enc_md_pos
= strchr (P_pos
, '*');
16411 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16413 uint32_t P_len
= enc_md_pos
- P_pos
;
16417 char *id_len_pos
= strchr (enc_md_pos
, '*');
16419 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16421 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16425 char *id_buf_pos
= strchr (id_len_pos
, '*');
16427 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16429 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16433 char *u_len_pos
= strchr (id_buf_pos
, '*');
16435 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16437 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16439 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16443 char *u_buf_pos
= strchr (u_len_pos
, '*');
16445 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16447 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16451 char *o_len_pos
= strchr (u_buf_pos
, '*');
16453 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16455 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16457 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16461 char *o_buf_pos
= strchr (o_len_pos
, '*');
16463 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16465 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16469 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;
16471 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16475 const int V
= atoi (V_pos
);
16476 const int R
= atoi (R_pos
);
16477 const int P
= atoi (P_pos
);
16481 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16482 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16484 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16486 const int id_len
= atoi (id_len_pos
);
16487 const int u_len
= atoi (u_len_pos
);
16488 const int o_len
= atoi (o_len_pos
);
16490 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16492 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16493 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16495 const int bits
= atoi (bits_pos
);
16497 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16503 enc_md
= atoi (enc_md_pos
);
16506 // copy data to esalt
16512 pdf
->enc_md
= enc_md
;
16514 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16515 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16516 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16517 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16521 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16522 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16523 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16524 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16527 pdf
->id_len
= id_len
;
16529 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16530 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16531 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16532 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16533 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16534 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16535 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16536 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16537 pdf
->u_len
= u_len
;
16539 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16540 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16541 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16542 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16543 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16544 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16545 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16546 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16547 pdf
->o_len
= o_len
;
16549 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16550 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16551 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16552 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16556 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16557 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16558 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16559 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16562 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16563 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16564 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16565 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16566 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16567 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16568 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16569 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16571 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16572 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16573 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16574 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16575 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16576 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16577 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16578 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16580 // precompute rc4 data for later use
16596 uint salt_pc_block
[32];
16598 char *salt_pc_ptr
= (char *) salt_pc_block
;
16600 memcpy (salt_pc_ptr
, padding
, 32);
16601 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16603 uint salt_pc_digest
[4];
16605 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16607 pdf
->rc4data
[0] = salt_pc_digest
[0];
16608 pdf
->rc4data
[1] = salt_pc_digest
[1];
16610 // we use ID for salt, maybe needs to change, we will see...
16612 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16613 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16614 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16615 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16616 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16617 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16618 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16619 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16620 salt
->salt_len
= pdf
->id_len
+ 16;
16622 salt
->salt_iter
= ROUNDS_PDF14
;
16624 digest
[0] = pdf
->u_buf
[0];
16625 digest
[1] = pdf
->u_buf
[1];
16629 return (PARSER_OK
);
16632 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16634 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16636 if (ret
!= PARSER_OK
)
16641 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16643 salt_t
*salt
= hash_buf
->salt
;
16645 digest
[0] -= SHA256M_A
;
16646 digest
[1] -= SHA256M_B
;
16647 digest
[2] -= SHA256M_C
;
16648 digest
[3] -= SHA256M_D
;
16649 digest
[4] -= SHA256M_E
;
16650 digest
[5] -= SHA256M_F
;
16651 digest
[6] -= SHA256M_G
;
16652 digest
[7] -= SHA256M_H
;
16654 salt
->salt_buf
[2] = 0x80;
16656 return (PARSER_OK
);
16659 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16661 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16663 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16665 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16667 salt_t
*salt
= hash_buf
->salt
;
16669 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16675 char *V_pos
= input_buf
+ 5;
16677 char *R_pos
= strchr (V_pos
, '*');
16679 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16681 uint32_t V_len
= R_pos
- V_pos
;
16685 char *bits_pos
= strchr (R_pos
, '*');
16687 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16689 uint32_t R_len
= bits_pos
- R_pos
;
16693 char *P_pos
= strchr (bits_pos
, '*');
16695 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16697 uint32_t bits_len
= P_pos
- bits_pos
;
16701 char *enc_md_pos
= strchr (P_pos
, '*');
16703 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16705 uint32_t P_len
= enc_md_pos
- P_pos
;
16709 char *id_len_pos
= strchr (enc_md_pos
, '*');
16711 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16713 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16717 char *id_buf_pos
= strchr (id_len_pos
, '*');
16719 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16721 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16725 char *u_len_pos
= strchr (id_buf_pos
, '*');
16727 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16729 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16733 char *u_buf_pos
= strchr (u_len_pos
, '*');
16735 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16737 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16741 char *o_len_pos
= strchr (u_buf_pos
, '*');
16743 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16745 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16749 char *o_buf_pos
= strchr (o_len_pos
, '*');
16751 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16753 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16757 char *last
= strchr (o_buf_pos
, '*');
16759 if (last
== NULL
) last
= input_buf
+ input_len
;
16761 uint32_t o_buf_len
= last
- o_buf_pos
;
16765 const int V
= atoi (V_pos
);
16766 const int R
= atoi (R_pos
);
16770 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16771 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16773 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16775 const int bits
= atoi (bits_pos
);
16777 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16779 int enc_md
= atoi (enc_md_pos
);
16781 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16783 const uint id_len
= atoi (id_len_pos
);
16784 const uint u_len
= atoi (u_len_pos
);
16785 const uint o_len
= atoi (o_len_pos
);
16787 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16788 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16789 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16790 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16791 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16792 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16793 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16794 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16796 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16797 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16798 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16800 // copy data to esalt
16802 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16804 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16806 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16809 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16810 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16812 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16813 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16815 salt
->salt_len
= 8;
16816 salt
->salt_iter
= ROUNDS_PDF17L8
;
16818 digest
[0] = pdf
->u_buf
[0];
16819 digest
[1] = pdf
->u_buf
[1];
16820 digest
[2] = pdf
->u_buf
[2];
16821 digest
[3] = pdf
->u_buf
[3];
16822 digest
[4] = pdf
->u_buf
[4];
16823 digest
[5] = pdf
->u_buf
[5];
16824 digest
[6] = pdf
->u_buf
[6];
16825 digest
[7] = pdf
->u_buf
[7];
16827 return (PARSER_OK
);
16830 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16832 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16834 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16836 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16838 salt_t
*salt
= hash_buf
->salt
;
16840 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16848 char *iter_pos
= input_buf
+ 7;
16850 uint32_t iter
= atoi (iter_pos
);
16852 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16853 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16855 // first is *raw* salt
16857 char *salt_pos
= strchr (iter_pos
, ':');
16859 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16863 char *hash_pos
= strchr (salt_pos
, ':');
16865 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16867 uint32_t salt_len
= hash_pos
- salt_pos
;
16869 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16873 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16875 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16879 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16881 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16883 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16885 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16886 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16888 salt
->salt_len
= salt_len
;
16889 salt
->salt_iter
= iter
- 1;
16895 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16897 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16899 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16901 memcpy (digest
, tmp_buf
, 16);
16903 digest
[0] = byte_swap_32 (digest
[0]);
16904 digest
[1] = byte_swap_32 (digest
[1]);
16905 digest
[2] = byte_swap_32 (digest
[2]);
16906 digest
[3] = byte_swap_32 (digest
[3]);
16908 // add some stuff to normal salt to make sorted happy
16910 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16911 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16912 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16913 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16914 salt
->salt_buf
[4] = salt
->salt_iter
;
16916 return (PARSER_OK
);
16919 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16921 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16923 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16925 salt_t
*salt
= hash_buf
->salt
;
16927 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16928 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16929 digest
[2] = hex_to_uint (&input_buf
[16]);
16930 digest
[3] = hex_to_uint (&input_buf
[24]);
16932 digest
[0] = byte_swap_32 (digest
[0]);
16933 digest
[1] = byte_swap_32 (digest
[1]);
16934 digest
[2] = byte_swap_32 (digest
[2]);
16935 digest
[3] = byte_swap_32 (digest
[3]);
16937 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16939 uint salt_len
= input_len
- 32 - 1;
16941 char *salt_buf
= input_buf
+ 32 + 1;
16943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16945 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16947 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16949 salt
->salt_len
= salt_len
;
16951 return (PARSER_OK
);
16954 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16956 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
16958 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16960 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16962 salt_t
*salt
= hash_buf
->salt
;
16964 char *user_pos
= input_buf
+ 10;
16966 char *salt_pos
= strchr (user_pos
, '*');
16968 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16972 char *hash_pos
= strchr (salt_pos
, '*');
16976 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16978 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
16980 uint user_len
= salt_pos
- user_pos
- 1;
16982 uint salt_len
= hash_pos
- salt_pos
- 1;
16984 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
16990 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
16991 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
16992 digest
[2] = hex_to_uint (&hash_pos
[16]);
16993 digest
[3] = hex_to_uint (&hash_pos
[24]);
16995 digest
[0] = byte_swap_32 (digest
[0]);
16996 digest
[1] = byte_swap_32 (digest
[1]);
16997 digest
[2] = byte_swap_32 (digest
[2]);
16998 digest
[3] = byte_swap_32 (digest
[3]);
17000 digest
[0] -= MD5M_A
;
17001 digest
[1] -= MD5M_B
;
17002 digest
[2] -= MD5M_C
;
17003 digest
[3] -= MD5M_D
;
17009 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17011 // first 4 bytes are the "challenge"
17013 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17014 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17015 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17016 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17018 // append the user name
17020 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17022 salt
->salt_len
= 4 + user_len
;
17024 return (PARSER_OK
);
17027 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17029 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17031 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17033 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17035 salt_t
*salt
= hash_buf
->salt
;
17037 char *salt_pos
= input_buf
+ 9;
17039 char *hash_pos
= strchr (salt_pos
, '*');
17041 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17045 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17047 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17049 uint salt_len
= hash_pos
- salt_pos
- 1;
17051 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17057 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17058 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17059 digest
[2] = hex_to_uint (&hash_pos
[16]);
17060 digest
[3] = hex_to_uint (&hash_pos
[24]);
17061 digest
[4] = hex_to_uint (&hash_pos
[32]);
17067 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17069 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17071 salt
->salt_len
= salt_len
;
17073 return (PARSER_OK
);
17076 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17078 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17080 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17082 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17084 salt_t
*salt
= hash_buf
->salt
;
17086 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17092 char *cry_master_len_pos
= input_buf
+ 9;
17094 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17096 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17098 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17100 cry_master_buf_pos
++;
17102 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17104 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17106 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17108 cry_salt_len_pos
++;
17110 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17112 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17114 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17116 cry_salt_buf_pos
++;
17118 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17120 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17122 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17126 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17128 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17130 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17134 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17136 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17138 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17142 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17144 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17146 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17148 public_key_len_pos
++;
17150 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17152 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17154 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17156 public_key_buf_pos
++;
17158 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;
17160 const uint cry_master_len
= atoi (cry_master_len_pos
);
17161 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17162 const uint ckey_len
= atoi (ckey_len_pos
);
17163 const uint public_key_len
= atoi (public_key_len_pos
);
17165 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17166 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17167 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17168 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17170 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17172 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17174 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17177 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17179 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17181 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17184 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17186 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17188 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17191 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17192 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17193 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17196 * store digest (should be unique enought, hopefully)
17199 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17200 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17201 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17202 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17208 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17210 const uint cry_rounds
= atoi (cry_rounds_pos
);
17212 salt
->salt_iter
= cry_rounds
- 1;
17214 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17216 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17218 salt
->salt_len
= salt_len
;
17220 return (PARSER_OK
);
17223 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17225 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17227 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17229 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17231 salt_t
*salt
= hash_buf
->salt
;
17233 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17235 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17237 char temp_input_buf
[input_len
+ 1];
17239 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17240 memcpy (temp_input_buf
, input_buf
, input_len
);
17244 char *URI_server_pos
= temp_input_buf
+ 6;
17246 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17248 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17250 URI_client_pos
[0] = 0;
17253 uint URI_server_len
= strlen (URI_server_pos
);
17255 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17259 char *user_pos
= strchr (URI_client_pos
, '*');
17261 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17266 uint URI_client_len
= strlen (URI_client_pos
);
17268 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17272 char *realm_pos
= strchr (user_pos
, '*');
17274 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17279 uint user_len
= strlen (user_pos
);
17281 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17285 char *method_pos
= strchr (realm_pos
, '*');
17287 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 uint realm_len
= strlen (realm_pos
);
17294 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17298 char *URI_prefix_pos
= strchr (method_pos
, '*');
17300 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 URI_prefix_pos
[0] = 0;
17305 uint method_len
= strlen (method_pos
);
17307 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17311 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17313 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17315 URI_resource_pos
[0] = 0;
17316 URI_resource_pos
++;
17318 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17320 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17324 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17326 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17328 URI_suffix_pos
[0] = 0;
17331 uint URI_resource_len
= strlen (URI_resource_pos
);
17333 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17334 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17338 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17340 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17345 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17347 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17351 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17353 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17355 nonce_client_pos
[0] = 0;
17356 nonce_client_pos
++;
17358 uint nonce_len
= strlen (nonce_pos
);
17360 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17361 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17365 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17367 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17369 nonce_count_pos
[0] = 0;
17372 uint nonce_client_len
= strlen (nonce_client_pos
);
17374 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17378 char *qop_pos
= strchr (nonce_count_pos
, '*');
17380 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17385 uint nonce_count_len
= strlen (nonce_count_pos
);
17387 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17391 char *directive_pos
= strchr (qop_pos
, '*');
17393 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17395 directive_pos
[0] = 0;
17398 uint qop_len
= strlen (qop_pos
);
17400 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17404 char *digest_pos
= strchr (directive_pos
, '*');
17406 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17411 uint directive_len
= strlen (directive_pos
);
17413 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17415 if (memcmp (directive_pos
, "MD5", 3))
17417 log_info ("ERROR: only the MD5 directive is currently supported\n");
17419 return (PARSER_SIP_AUTH_DIRECTIVE
);
17423 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17428 uint md5_max_len
= 4 * 64;
17430 uint md5_remaining_len
= md5_max_len
;
17432 uint tmp_md5_buf
[md5_max_len
/ 4];
17434 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17436 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17438 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17440 md5_len
+= method_len
+ 1;
17441 tmp_md5_ptr
+= method_len
+ 1;
17443 if (URI_prefix_len
> 0)
17445 md5_remaining_len
= md5_max_len
- md5_len
;
17447 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17449 md5_len
+= URI_prefix_len
+ 1;
17450 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17453 md5_remaining_len
= md5_max_len
- md5_len
;
17455 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17457 md5_len
+= URI_resource_len
;
17458 tmp_md5_ptr
+= URI_resource_len
;
17460 if (URI_suffix_len
> 0)
17462 md5_remaining_len
= md5_max_len
- md5_len
;
17464 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17466 md5_len
+= 1 + URI_suffix_len
;
17469 uint tmp_digest
[4];
17471 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17473 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17474 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17475 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17476 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17482 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17484 uint esalt_len
= 0;
17486 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17488 // there are 2 possibilities for the esalt:
17490 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17492 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17494 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17496 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17508 esalt_len
= 1 + nonce_len
+ 1 + 32;
17510 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17512 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17520 // add 0x80 to esalt
17522 esalt_buf_ptr
[esalt_len
] = 0x80;
17524 sip
->esalt_len
= esalt_len
;
17530 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17532 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17534 uint max_salt_len
= 119;
17536 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17538 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17540 sip
->salt_len
= salt_len
;
17543 * fake salt (for sorting)
17546 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17550 uint fake_salt_len
= salt_len
;
17552 if (fake_salt_len
> max_salt_len
)
17554 fake_salt_len
= max_salt_len
;
17557 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17559 salt
->salt_len
= fake_salt_len
;
17565 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17566 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17567 digest
[2] = hex_to_uint (&digest_pos
[16]);
17568 digest
[3] = hex_to_uint (&digest_pos
[24]);
17570 digest
[0] = byte_swap_32 (digest
[0]);
17571 digest
[1] = byte_swap_32 (digest
[1]);
17572 digest
[2] = byte_swap_32 (digest
[2]);
17573 digest
[3] = byte_swap_32 (digest
[3]);
17575 return (PARSER_OK
);
17578 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17580 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17582 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17584 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17586 salt_t
*salt
= hash_buf
->salt
;
17590 char *digest_pos
= input_buf
;
17592 digest
[0] = hex_to_uint (&digest_pos
[0]);
17599 char *salt_buf
= input_buf
+ 8 + 1;
17603 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17605 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17607 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17609 salt
->salt_len
= salt_len
;
17611 return (PARSER_OK
);
17614 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17616 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17618 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17620 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17622 salt_t
*salt
= hash_buf
->salt
;
17624 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17630 char *p_buf_pos
= input_buf
+ 4;
17632 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17634 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17636 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17638 NumCyclesPower_pos
++;
17640 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17642 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17644 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17648 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17650 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17652 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17656 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17658 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17660 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17664 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17666 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17668 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17672 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17674 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17676 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17680 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17682 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17684 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17688 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17690 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17692 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17696 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17698 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17700 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17704 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;
17706 const uint iter
= atoi (NumCyclesPower_pos
);
17707 const uint crc
= atoi (crc_buf_pos
);
17708 const uint p_buf
= atoi (p_buf_pos
);
17709 const uint salt_len
= atoi (salt_len_pos
);
17710 const uint iv_len
= atoi (iv_len_pos
);
17711 const uint unpack_size
= atoi (unpack_size_pos
);
17712 const uint data_len
= atoi (data_len_pos
);
17718 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17719 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17721 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17723 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17725 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17731 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17732 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17733 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17734 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17736 seven_zip
->iv_len
= iv_len
;
17738 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17740 seven_zip
->salt_len
= 0;
17742 seven_zip
->crc
= crc
;
17744 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17746 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17748 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17751 seven_zip
->data_len
= data_len
;
17753 seven_zip
->unpack_size
= unpack_size
;
17757 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17758 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17759 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17760 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17762 salt
->salt_len
= 16;
17764 salt
->salt_sign
[0] = iter
;
17766 salt
->salt_iter
= 1 << iter
;
17777 return (PARSER_OK
);
17780 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17782 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17784 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17786 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17787 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17788 digest
[2] = hex_to_uint (&input_buf
[16]);
17789 digest
[3] = hex_to_uint (&input_buf
[24]);
17790 digest
[4] = hex_to_uint (&input_buf
[32]);
17791 digest
[5] = hex_to_uint (&input_buf
[40]);
17792 digest
[6] = hex_to_uint (&input_buf
[48]);
17793 digest
[7] = hex_to_uint (&input_buf
[56]);
17795 digest
[0] = byte_swap_32 (digest
[0]);
17796 digest
[1] = byte_swap_32 (digest
[1]);
17797 digest
[2] = byte_swap_32 (digest
[2]);
17798 digest
[3] = byte_swap_32 (digest
[3]);
17799 digest
[4] = byte_swap_32 (digest
[4]);
17800 digest
[5] = byte_swap_32 (digest
[5]);
17801 digest
[6] = byte_swap_32 (digest
[6]);
17802 digest
[7] = byte_swap_32 (digest
[7]);
17804 return (PARSER_OK
);
17807 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17809 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17811 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17813 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17814 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17815 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17816 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17817 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17818 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17819 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17820 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17821 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17822 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17823 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17824 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17825 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17826 digest
[13] = hex_to_uint (&input_buf
[104]);
17827 digest
[14] = hex_to_uint (&input_buf
[112]);
17828 digest
[15] = hex_to_uint (&input_buf
[120]);
17830 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17831 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17832 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17833 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17834 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17835 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17836 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17837 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17838 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17839 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17840 digest
[10] = byte_swap_32 (digest
[10]);
17841 digest
[11] = byte_swap_32 (digest
[11]);
17842 digest
[12] = byte_swap_32 (digest
[12]);
17843 digest
[13] = byte_swap_32 (digest
[13]);
17844 digest
[14] = byte_swap_32 (digest
[14]);
17845 digest
[15] = byte_swap_32 (digest
[15]);
17847 return (PARSER_OK
);
17850 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17852 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17854 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17856 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17858 salt_t
*salt
= hash_buf
->salt
;
17860 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17868 char *iter_pos
= input_buf
+ 4;
17870 uint32_t iter
= atoi (iter_pos
);
17872 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17873 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17875 // first is *raw* salt
17877 char *salt_pos
= strchr (iter_pos
, ':');
17879 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17883 char *hash_pos
= strchr (salt_pos
, ':');
17885 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17887 uint32_t salt_len
= hash_pos
- salt_pos
;
17889 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17893 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17895 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17899 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17901 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17903 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17905 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17906 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17908 salt
->salt_len
= salt_len
;
17909 salt
->salt_iter
= iter
- 1;
17915 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17917 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17919 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17921 memcpy (digest
, tmp_buf
, 16);
17923 // add some stuff to normal salt to make sorted happy
17925 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17926 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17927 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17928 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17929 salt
->salt_buf
[4] = salt
->salt_iter
;
17931 return (PARSER_OK
);
17934 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17936 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17938 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17940 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17942 salt_t
*salt
= hash_buf
->salt
;
17944 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
17952 char *iter_pos
= input_buf
+ 5;
17954 uint32_t iter
= atoi (iter_pos
);
17956 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17957 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17959 // first is *raw* salt
17961 char *salt_pos
= strchr (iter_pos
, ':');
17963 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17967 char *hash_pos
= strchr (salt_pos
, ':');
17969 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17971 uint32_t salt_len
= hash_pos
- salt_pos
;
17973 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17977 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17979 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17983 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
17985 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17987 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17989 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17990 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17992 salt
->salt_len
= salt_len
;
17993 salt
->salt_iter
= iter
- 1;
17999 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18001 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18003 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18005 memcpy (digest
, tmp_buf
, 16);
18007 digest
[0] = byte_swap_32 (digest
[0]);
18008 digest
[1] = byte_swap_32 (digest
[1]);
18009 digest
[2] = byte_swap_32 (digest
[2]);
18010 digest
[3] = byte_swap_32 (digest
[3]);
18012 // add some stuff to normal salt to make sorted happy
18014 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18015 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18016 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18017 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18018 salt
->salt_buf
[4] = salt
->salt_iter
;
18020 return (PARSER_OK
);
18023 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18025 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18027 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18029 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18031 salt_t
*salt
= hash_buf
->salt
;
18033 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18041 char *iter_pos
= input_buf
+ 7;
18043 uint32_t iter
= atoi (iter_pos
);
18045 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18046 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18048 // first is *raw* salt
18050 char *salt_pos
= strchr (iter_pos
, ':');
18052 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18056 char *hash_pos
= strchr (salt_pos
, ':');
18058 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18060 uint32_t salt_len
= hash_pos
- salt_pos
;
18062 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18066 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18068 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18072 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18074 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18076 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18078 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18079 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18081 salt
->salt_len
= salt_len
;
18082 salt
->salt_iter
= iter
- 1;
18088 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18090 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18092 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18094 memcpy (digest
, tmp_buf
, 64);
18096 digest
[0] = byte_swap_64 (digest
[0]);
18097 digest
[1] = byte_swap_64 (digest
[1]);
18098 digest
[2] = byte_swap_64 (digest
[2]);
18099 digest
[3] = byte_swap_64 (digest
[3]);
18100 digest
[4] = byte_swap_64 (digest
[4]);
18101 digest
[5] = byte_swap_64 (digest
[5]);
18102 digest
[6] = byte_swap_64 (digest
[6]);
18103 digest
[7] = byte_swap_64 (digest
[7]);
18105 // add some stuff to normal salt to make sorted happy
18107 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18108 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18109 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18110 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18111 salt
->salt_buf
[4] = salt
->salt_iter
;
18113 return (PARSER_OK
);
18116 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18118 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18120 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18122 uint
*digest
= (uint
*) hash_buf
->digest
;
18124 salt_t
*salt
= hash_buf
->salt
;
18130 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18132 char *hash_pos
= strchr (salt_pos
, '$');
18134 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18136 uint32_t salt_len
= hash_pos
- salt_pos
;
18138 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18142 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18144 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18148 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18149 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18167 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18168 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18170 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18171 salt
->salt_len
= 8;
18173 return (PARSER_OK
);
18176 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18178 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18180 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18182 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18184 if (c19
& 3) return (PARSER_HASH_VALUE
);
18186 salt_t
*salt
= hash_buf
->salt
;
18188 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18192 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18193 | itoa64_to_int (input_buf
[2]) << 6
18194 | itoa64_to_int (input_buf
[3]) << 12
18195 | itoa64_to_int (input_buf
[4]) << 18;
18199 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18200 | itoa64_to_int (input_buf
[6]) << 6
18201 | itoa64_to_int (input_buf
[7]) << 12
18202 | itoa64_to_int (input_buf
[8]) << 18;
18204 salt
->salt_len
= 4;
18208 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18210 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18212 memcpy (digest
, tmp_buf
, 8);
18216 IP (digest
[0], digest
[1], tt
);
18218 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18219 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18223 return (PARSER_OK
);
18226 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18228 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18230 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18232 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18234 salt_t
*salt
= hash_buf
->salt
;
18240 char *type_pos
= input_buf
+ 6 + 1;
18242 char *salt_pos
= strchr (type_pos
, '*');
18244 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18246 uint32_t type_len
= salt_pos
- type_pos
;
18248 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18252 char *crypted_pos
= strchr (salt_pos
, '*');
18254 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18256 uint32_t salt_len
= crypted_pos
- salt_pos
;
18258 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18262 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18264 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18270 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18271 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18273 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18274 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18276 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18277 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18278 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18279 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18281 salt
->salt_len
= 24;
18282 salt
->salt_iter
= ROUNDS_RAR3
;
18284 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18285 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18287 digest
[0] = 0xc43d7b00;
18288 digest
[1] = 0x40070000;
18292 return (PARSER_OK
);
18295 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18297 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18299 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18301 salt_t
*salt
= hash_buf
->salt
;
18303 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18304 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18305 digest
[2] = hex_to_uint (&input_buf
[16]);
18306 digest
[3] = hex_to_uint (&input_buf
[24]);
18307 digest
[4] = hex_to_uint (&input_buf
[32]);
18308 digest
[5] = hex_to_uint (&input_buf
[40]);
18309 digest
[6] = hex_to_uint (&input_buf
[48]);
18310 digest
[7] = hex_to_uint (&input_buf
[56]);
18312 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18314 uint salt_len
= input_len
- 64 - 1;
18316 char *salt_buf
= input_buf
+ 64 + 1;
18318 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18324 salt
->salt_len
= salt_len
;
18327 * we can precompute the first sha256 transform
18332 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18333 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18334 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18335 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18336 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18337 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18338 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18339 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18340 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18341 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18342 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18343 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18344 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18345 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18346 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18347 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18351 pc256
[0] = SHA256M_A
;
18352 pc256
[1] = SHA256M_B
;
18353 pc256
[2] = SHA256M_C
;
18354 pc256
[3] = SHA256M_D
;
18355 pc256
[4] = SHA256M_E
;
18356 pc256
[5] = SHA256M_F
;
18357 pc256
[6] = SHA256M_G
;
18358 pc256
[7] = SHA256M_H
;
18360 sha256_64 (w
, pc256
);
18362 salt
->salt_buf_pc
[0] = pc256
[0];
18363 salt
->salt_buf_pc
[1] = pc256
[1];
18364 salt
->salt_buf_pc
[2] = pc256
[2];
18365 salt
->salt_buf_pc
[3] = pc256
[3];
18366 salt
->salt_buf_pc
[4] = pc256
[4];
18367 salt
->salt_buf_pc
[5] = pc256
[5];
18368 salt
->salt_buf_pc
[6] = pc256
[6];
18369 salt
->salt_buf_pc
[7] = pc256
[7];
18371 digest
[0] -= pc256
[0];
18372 digest
[1] -= pc256
[1];
18373 digest
[2] -= pc256
[2];
18374 digest
[3] -= pc256
[3];
18375 digest
[4] -= pc256
[4];
18376 digest
[5] -= pc256
[5];
18377 digest
[6] -= pc256
[6];
18378 digest
[7] -= pc256
[7];
18380 return (PARSER_OK
);
18383 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18385 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18387 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18389 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18391 salt_t
*salt
= hash_buf
->salt
;
18397 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18399 char *data_buf_pos
= strchr (data_len_pos
, '$');
18401 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18403 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18405 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18406 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18410 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18412 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18414 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18416 uint32_t data_len
= atoi (data_len_pos
);
18418 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18424 char *salt_pos
= data_buf_pos
;
18426 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18427 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18428 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18429 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18431 // this is actually the CT, which is also the hash later (if matched)
18433 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18434 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18435 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18436 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18438 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18440 salt
->salt_iter
= 10 - 1;
18446 digest
[0] = salt
->salt_buf
[4];
18447 digest
[1] = salt
->salt_buf
[5];
18448 digest
[2] = salt
->salt_buf
[6];
18449 digest
[3] = salt
->salt_buf
[7];
18451 return (PARSER_OK
);
18454 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18456 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18458 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18460 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18462 salt_t
*salt
= hash_buf
->salt
;
18468 char *salt_pos
= input_buf
+ 11 + 1;
18470 char *iter_pos
= strchr (salt_pos
, ',');
18472 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18474 uint32_t salt_len
= iter_pos
- salt_pos
;
18476 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18480 char *hash_pos
= strchr (iter_pos
, ',');
18482 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18484 uint32_t iter_len
= hash_pos
- iter_pos
;
18486 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18490 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18492 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18498 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18499 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18500 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18501 salt
->salt_buf
[3] = 0x00018000;
18503 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18504 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18505 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18506 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18508 salt
->salt_len
= salt_len
/ 2;
18510 salt
->salt_iter
= atoi (iter_pos
) - 1;
18516 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18517 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18518 digest
[2] = hex_to_uint (&hash_pos
[16]);
18519 digest
[3] = hex_to_uint (&hash_pos
[24]);
18520 digest
[4] = hex_to_uint (&hash_pos
[32]);
18521 digest
[5] = hex_to_uint (&hash_pos
[40]);
18522 digest
[6] = hex_to_uint (&hash_pos
[48]);
18523 digest
[7] = hex_to_uint (&hash_pos
[56]);
18525 return (PARSER_OK
);
18529 * parallel running threads
18534 BOOL WINAPI
sigHandler_default (DWORD sig
)
18538 case CTRL_CLOSE_EVENT
:
18541 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18542 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18543 * function otherwise it is to late (e.g. after returning from this function)
18548 SetConsoleCtrlHandler (NULL
, TRUE
);
18555 case CTRL_LOGOFF_EVENT
:
18556 case CTRL_SHUTDOWN_EVENT
:
18560 SetConsoleCtrlHandler (NULL
, TRUE
);
18568 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18572 case CTRL_CLOSE_EVENT
:
18576 SetConsoleCtrlHandler (NULL
, TRUE
);
18583 case CTRL_LOGOFF_EVENT
:
18584 case CTRL_SHUTDOWN_EVENT
:
18588 SetConsoleCtrlHandler (NULL
, TRUE
);
18596 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18598 if (callback
== NULL
)
18600 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18604 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18610 void sigHandler_default (int sig
)
18614 signal (sig
, NULL
);
18617 void sigHandler_benchmark (int sig
)
18621 signal (sig
, NULL
);
18624 void hc_signal (void (callback
) (int))
18626 if (callback
== NULL
) callback
= SIG_DFL
;
18628 signal (SIGINT
, callback
);
18629 signal (SIGTERM
, callback
);
18630 signal (SIGABRT
, callback
);
18635 void status_display ();
18637 void *thread_keypress (void *p
)
18639 int benchmark
= *((int *) p
);
18641 uint quiet
= data
.quiet
;
18645 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18647 int ch
= tty_getchar();
18649 if (ch
== -1) break;
18651 if (ch
== 0) continue;
18657 hc_thread_mutex_lock (mux_display
);
18672 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18673 if (quiet
== 0) fflush (stdout
);
18685 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18686 if (quiet
== 0) fflush (stdout
);
18698 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18699 if (quiet
== 0) fflush (stdout
);
18711 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18712 if (quiet
== 0) fflush (stdout
);
18720 if (benchmark
== 1)
18732 hc_thread_mutex_unlock (mux_display
);
18744 bool class_num (char c
)
18746 return ((c
>= '0') && (c
<= '9'));
18749 bool class_lower (char c
)
18751 return ((c
>= 'a') && (c
<= 'z'));
18754 bool class_upper (char c
)
18756 return ((c
>= 'A') && (c
<= 'Z'));
18759 bool class_alpha (char c
)
18761 return (class_lower (c
) || class_upper (c
));
18764 char conv_ctoi (char c
)
18770 else if (class_upper (c
))
18772 return c
- 'A' + (char) 10;
18775 return (char) (-1);
18778 char conv_itoc (char c
)
18786 return c
+ 'A' - (char) 10;
18789 return (char) (-1);
18796 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18797 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18798 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18799 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18800 #define MAX_GPU_RULES 14
18801 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18802 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18803 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18805 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18806 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18807 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18808 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18810 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18815 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18817 switch (rule_buf
[rule_pos
])
18823 case RULE_OP_MANGLE_NOOP
:
18824 SET_NAME (rule
, rule_buf
[rule_pos
]);
18827 case RULE_OP_MANGLE_LREST
:
18828 SET_NAME (rule
, rule_buf
[rule_pos
]);
18831 case RULE_OP_MANGLE_UREST
:
18832 SET_NAME (rule
, rule_buf
[rule_pos
]);
18835 case RULE_OP_MANGLE_LREST_UFIRST
:
18836 SET_NAME (rule
, rule_buf
[rule_pos
]);
18839 case RULE_OP_MANGLE_UREST_LFIRST
:
18840 SET_NAME (rule
, rule_buf
[rule_pos
]);
18843 case RULE_OP_MANGLE_TREST
:
18844 SET_NAME (rule
, rule_buf
[rule_pos
]);
18847 case RULE_OP_MANGLE_TOGGLE_AT
:
18848 SET_NAME (rule
, rule_buf
[rule_pos
]);
18849 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18852 case RULE_OP_MANGLE_REVERSE
:
18853 SET_NAME (rule
, rule_buf
[rule_pos
]);
18856 case RULE_OP_MANGLE_DUPEWORD
:
18857 SET_NAME (rule
, rule_buf
[rule_pos
]);
18860 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18861 SET_NAME (rule
, rule_buf
[rule_pos
]);
18862 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18865 case RULE_OP_MANGLE_REFLECT
:
18866 SET_NAME (rule
, rule_buf
[rule_pos
]);
18869 case RULE_OP_MANGLE_ROTATE_LEFT
:
18870 SET_NAME (rule
, rule_buf
[rule_pos
]);
18873 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18874 SET_NAME (rule
, rule_buf
[rule_pos
]);
18877 case RULE_OP_MANGLE_APPEND
:
18878 SET_NAME (rule
, rule_buf
[rule_pos
]);
18879 SET_P0 (rule
, rule_buf
[rule_pos
]);
18882 case RULE_OP_MANGLE_PREPEND
:
18883 SET_NAME (rule
, rule_buf
[rule_pos
]);
18884 SET_P0 (rule
, rule_buf
[rule_pos
]);
18887 case RULE_OP_MANGLE_DELETE_FIRST
:
18888 SET_NAME (rule
, rule_buf
[rule_pos
]);
18891 case RULE_OP_MANGLE_DELETE_LAST
:
18892 SET_NAME (rule
, rule_buf
[rule_pos
]);
18895 case RULE_OP_MANGLE_DELETE_AT
:
18896 SET_NAME (rule
, rule_buf
[rule_pos
]);
18897 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18900 case RULE_OP_MANGLE_EXTRACT
:
18901 SET_NAME (rule
, rule_buf
[rule_pos
]);
18902 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18903 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18906 case RULE_OP_MANGLE_OMIT
:
18907 SET_NAME (rule
, rule_buf
[rule_pos
]);
18908 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18909 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18912 case RULE_OP_MANGLE_INSERT
:
18913 SET_NAME (rule
, rule_buf
[rule_pos
]);
18914 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18915 SET_P1 (rule
, rule_buf
[rule_pos
]);
18918 case RULE_OP_MANGLE_OVERSTRIKE
:
18919 SET_NAME (rule
, rule_buf
[rule_pos
]);
18920 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18921 SET_P1 (rule
, rule_buf
[rule_pos
]);
18924 case RULE_OP_MANGLE_TRUNCATE_AT
:
18925 SET_NAME (rule
, rule_buf
[rule_pos
]);
18926 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18929 case RULE_OP_MANGLE_REPLACE
:
18930 SET_NAME (rule
, rule_buf
[rule_pos
]);
18931 SET_P0 (rule
, rule_buf
[rule_pos
]);
18932 SET_P1 (rule
, rule_buf
[rule_pos
]);
18935 case RULE_OP_MANGLE_PURGECHAR
:
18939 case RULE_OP_MANGLE_TOGGLECASE_REC
:
18943 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
18944 SET_NAME (rule
, rule_buf
[rule_pos
]);
18945 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18948 case RULE_OP_MANGLE_DUPECHAR_LAST
:
18949 SET_NAME (rule
, rule_buf
[rule_pos
]);
18950 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18953 case RULE_OP_MANGLE_DUPECHAR_ALL
:
18954 SET_NAME (rule
, rule_buf
[rule_pos
]);
18957 case RULE_OP_MANGLE_SWITCH_FIRST
:
18958 SET_NAME (rule
, rule_buf
[rule_pos
]);
18961 case RULE_OP_MANGLE_SWITCH_LAST
:
18962 SET_NAME (rule
, rule_buf
[rule_pos
]);
18965 case RULE_OP_MANGLE_SWITCH_AT
:
18966 SET_NAME (rule
, rule_buf
[rule_pos
]);
18967 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18968 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18971 case RULE_OP_MANGLE_CHR_SHIFTL
:
18972 SET_NAME (rule
, rule_buf
[rule_pos
]);
18973 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18976 case RULE_OP_MANGLE_CHR_SHIFTR
:
18977 SET_NAME (rule
, rule_buf
[rule_pos
]);
18978 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18981 case RULE_OP_MANGLE_CHR_INCR
:
18982 SET_NAME (rule
, rule_buf
[rule_pos
]);
18983 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18986 case RULE_OP_MANGLE_CHR_DECR
:
18987 SET_NAME (rule
, rule_buf
[rule_pos
]);
18988 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18991 case RULE_OP_MANGLE_REPLACE_NP1
:
18992 SET_NAME (rule
, rule_buf
[rule_pos
]);
18993 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18996 case RULE_OP_MANGLE_REPLACE_NM1
:
18997 SET_NAME (rule
, rule_buf
[rule_pos
]);
18998 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19001 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19002 SET_NAME (rule
, rule_buf
[rule_pos
]);
19003 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19006 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19007 SET_NAME (rule
, rule_buf
[rule_pos
]);
19008 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19011 case RULE_OP_MANGLE_TITLE
:
19012 SET_NAME (rule
, rule_buf
[rule_pos
]);
19021 if (rule_pos
< rule_len
) return (-1);
19026 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19030 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19034 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19038 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19042 case RULE_OP_MANGLE_NOOP
:
19043 rule_buf
[rule_pos
] = rule_cmd
;
19046 case RULE_OP_MANGLE_LREST
:
19047 rule_buf
[rule_pos
] = rule_cmd
;
19050 case RULE_OP_MANGLE_UREST
:
19051 rule_buf
[rule_pos
] = rule_cmd
;
19054 case RULE_OP_MANGLE_LREST_UFIRST
:
19055 rule_buf
[rule_pos
] = rule_cmd
;
19058 case RULE_OP_MANGLE_UREST_LFIRST
:
19059 rule_buf
[rule_pos
] = rule_cmd
;
19062 case RULE_OP_MANGLE_TREST
:
19063 rule_buf
[rule_pos
] = rule_cmd
;
19066 case RULE_OP_MANGLE_TOGGLE_AT
:
19067 rule_buf
[rule_pos
] = rule_cmd
;
19068 GET_P0_CONV (rule
);
19071 case RULE_OP_MANGLE_REVERSE
:
19072 rule_buf
[rule_pos
] = rule_cmd
;
19075 case RULE_OP_MANGLE_DUPEWORD
:
19076 rule_buf
[rule_pos
] = rule_cmd
;
19079 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19080 rule_buf
[rule_pos
] = rule_cmd
;
19081 GET_P0_CONV (rule
);
19084 case RULE_OP_MANGLE_REFLECT
:
19085 rule_buf
[rule_pos
] = rule_cmd
;
19088 case RULE_OP_MANGLE_ROTATE_LEFT
:
19089 rule_buf
[rule_pos
] = rule_cmd
;
19092 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19093 rule_buf
[rule_pos
] = rule_cmd
;
19096 case RULE_OP_MANGLE_APPEND
:
19097 rule_buf
[rule_pos
] = rule_cmd
;
19101 case RULE_OP_MANGLE_PREPEND
:
19102 rule_buf
[rule_pos
] = rule_cmd
;
19106 case RULE_OP_MANGLE_DELETE_FIRST
:
19107 rule_buf
[rule_pos
] = rule_cmd
;
19110 case RULE_OP_MANGLE_DELETE_LAST
:
19111 rule_buf
[rule_pos
] = rule_cmd
;
19114 case RULE_OP_MANGLE_DELETE_AT
:
19115 rule_buf
[rule_pos
] = rule_cmd
;
19116 GET_P0_CONV (rule
);
19119 case RULE_OP_MANGLE_EXTRACT
:
19120 rule_buf
[rule_pos
] = rule_cmd
;
19121 GET_P0_CONV (rule
);
19122 GET_P1_CONV (rule
);
19125 case RULE_OP_MANGLE_OMIT
:
19126 rule_buf
[rule_pos
] = rule_cmd
;
19127 GET_P0_CONV (rule
);
19128 GET_P1_CONV (rule
);
19131 case RULE_OP_MANGLE_INSERT
:
19132 rule_buf
[rule_pos
] = rule_cmd
;
19133 GET_P0_CONV (rule
);
19137 case RULE_OP_MANGLE_OVERSTRIKE
:
19138 rule_buf
[rule_pos
] = rule_cmd
;
19139 GET_P0_CONV (rule
);
19143 case RULE_OP_MANGLE_TRUNCATE_AT
:
19144 rule_buf
[rule_pos
] = rule_cmd
;
19145 GET_P0_CONV (rule
);
19148 case RULE_OP_MANGLE_REPLACE
:
19149 rule_buf
[rule_pos
] = rule_cmd
;
19154 case RULE_OP_MANGLE_PURGECHAR
:
19158 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19162 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19163 rule_buf
[rule_pos
] = rule_cmd
;
19164 GET_P0_CONV (rule
);
19167 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19168 rule_buf
[rule_pos
] = rule_cmd
;
19169 GET_P0_CONV (rule
);
19172 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19173 rule_buf
[rule_pos
] = rule_cmd
;
19176 case RULE_OP_MANGLE_SWITCH_FIRST
:
19177 rule_buf
[rule_pos
] = rule_cmd
;
19180 case RULE_OP_MANGLE_SWITCH_LAST
:
19181 rule_buf
[rule_pos
] = rule_cmd
;
19184 case RULE_OP_MANGLE_SWITCH_AT
:
19185 rule_buf
[rule_pos
] = rule_cmd
;
19186 GET_P0_CONV (rule
);
19187 GET_P1_CONV (rule
);
19190 case RULE_OP_MANGLE_CHR_SHIFTL
:
19191 rule_buf
[rule_pos
] = rule_cmd
;
19192 GET_P0_CONV (rule
);
19195 case RULE_OP_MANGLE_CHR_SHIFTR
:
19196 rule_buf
[rule_pos
] = rule_cmd
;
19197 GET_P0_CONV (rule
);
19200 case RULE_OP_MANGLE_CHR_INCR
:
19201 rule_buf
[rule_pos
] = rule_cmd
;
19202 GET_P0_CONV (rule
);
19205 case RULE_OP_MANGLE_CHR_DECR
:
19206 rule_buf
[rule_pos
] = rule_cmd
;
19207 GET_P0_CONV (rule
);
19210 case RULE_OP_MANGLE_REPLACE_NP1
:
19211 rule_buf
[rule_pos
] = rule_cmd
;
19212 GET_P0_CONV (rule
);
19215 case RULE_OP_MANGLE_REPLACE_NM1
:
19216 rule_buf
[rule_pos
] = rule_cmd
;
19217 GET_P0_CONV (rule
);
19220 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19221 rule_buf
[rule_pos
] = rule_cmd
;
19222 GET_P0_CONV (rule
);
19225 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19226 rule_buf
[rule_pos
] = rule_cmd
;
19227 GET_P0_CONV (rule
);
19230 case RULE_OP_MANGLE_TITLE
:
19231 rule_buf
[rule_pos
] = rule_cmd
;
19235 return rule_pos
- 1;
19253 * CPU rules : this is from hashcat sources, cpu based rules
19256 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19257 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19259 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19260 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19261 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19263 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19264 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19265 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19267 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19271 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19276 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19280 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19285 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19289 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19294 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19299 for (l
= 0; l
< arr_len
; l
++)
19301 r
= arr_len
- 1 - l
;
19305 MANGLE_SWITCH (arr
, l
, r
);
19311 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19313 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19315 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19317 return (arr_len
* 2);
19320 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19322 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19324 int orig_len
= arr_len
;
19328 for (i
= 0; i
< times
; i
++)
19330 memcpy (&arr
[arr_len
], arr
, orig_len
);
19332 arr_len
+= orig_len
;
19338 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19340 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19342 mangle_double (arr
, arr_len
);
19344 mangle_reverse (arr
+ arr_len
, arr_len
);
19346 return (arr_len
* 2);
19349 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19354 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19356 MANGLE_SWITCH (arr
, l
, r
);
19362 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19367 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19369 MANGLE_SWITCH (arr
, l
, r
);
19375 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19377 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19381 return (arr_len
+ 1);
19384 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19386 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19390 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19392 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19397 return (arr_len
+ 1);
19400 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19402 if (upos
>= arr_len
) return (arr_len
);
19406 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19408 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19411 return (arr_len
- 1);
19414 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19416 if (upos
>= arr_len
) return (arr_len
);
19418 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19422 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19424 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19430 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19432 if (upos
>= arr_len
) return (arr_len
);
19434 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19438 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19440 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19443 return (arr_len
- ulen
);
19446 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19448 if (upos
>= arr_len
) return (arr_len
);
19450 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19454 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19456 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19461 return (arr_len
+ 1);
19464 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
)
19466 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19468 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19470 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19472 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19474 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19476 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19478 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19480 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19482 return (arr_len
+ arr2_cpy
);
19485 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19487 if (upos
>= arr_len
) return (arr_len
);
19494 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19496 if (upos
>= arr_len
) return (arr_len
);
19498 memset (arr
+ upos
, 0, arr_len
- upos
);
19503 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19507 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19509 if (arr
[arr_pos
] != oldc
) continue;
19511 arr
[arr_pos
] = newc
;
19517 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19523 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19525 if (arr
[arr_pos
] == c
) continue;
19527 arr
[ret_len
] = arr
[arr_pos
];
19535 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19537 if (ulen
> arr_len
) return (arr_len
);
19539 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19543 memcpy (cs
, arr
, ulen
);
19547 for (i
= 0; i
< ulen
; i
++)
19551 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19557 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19559 if (ulen
> arr_len
) return (arr_len
);
19561 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19563 int upos
= arr_len
- ulen
;
19567 for (i
= 0; i
< ulen
; i
++)
19569 char c
= arr
[upos
+ i
];
19571 arr_len
= mangle_append (arr
, arr_len
, c
);
19577 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19579 if ( arr_len
== 0) return (arr_len
);
19580 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19582 char c
= arr
[upos
];
19586 for (i
= 0; i
< ulen
; i
++)
19588 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19594 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19596 if ( arr_len
== 0) return (arr_len
);
19597 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19601 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19603 int new_pos
= arr_pos
* 2;
19605 arr
[new_pos
] = arr
[arr_pos
];
19607 arr
[new_pos
+ 1] = arr
[arr_pos
];
19610 return (arr_len
* 2);
19613 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19615 if (upos
>= arr_len
) return (arr_len
);
19616 if (upos2
>= arr_len
) return (arr_len
);
19618 MANGLE_SWITCH (arr
, upos
, upos2
);
19623 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19625 MANGLE_SWITCH (arr
, upos
, upos2
);
19630 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19632 if (upos
>= arr_len
) return (arr_len
);
19639 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19641 if (upos
>= arr_len
) return (arr_len
);
19648 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19650 if (upos
>= arr_len
) return (arr_len
);
19657 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19659 if (upos
>= arr_len
) return (arr_len
);
19666 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19668 int upper_next
= 1;
19672 for (pos
= 0; pos
< arr_len
; pos
++)
19674 if (arr
[pos
] == ' ')
19685 MANGLE_UPPER_AT (arr
, pos
);
19689 MANGLE_LOWER_AT (arr
, pos
);
19696 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19698 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19702 uint32_t rule_pos
= 0;
19704 for (j
= 0; j
< rp_gen_num
; j
++)
19711 switch ((char) get_random_num (0, 9))
19714 r
= get_random_num (0, sizeof (grp_op_nop
));
19715 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19719 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19720 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19721 p1
= get_random_num (0, sizeof (grp_pos
));
19722 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19726 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19727 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19728 p1
= get_random_num (1, 6);
19729 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19733 r
= get_random_num (0, sizeof (grp_op_chr
));
19734 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19735 p1
= get_random_num (0x20, 0x7e);
19736 rule_buf
[rule_pos
++] = (char) p1
;
19740 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19741 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19742 p1
= get_random_num (0x20, 0x7e);
19743 rule_buf
[rule_pos
++] = (char) p1
;
19744 p2
= get_random_num (0x20, 0x7e);
19746 p2
= get_random_num (0x20, 0x7e);
19747 rule_buf
[rule_pos
++] = (char) p2
;
19751 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19752 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19753 p1
= get_random_num (0, sizeof (grp_pos
));
19754 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19755 p2
= get_random_num (0x20, 0x7e);
19756 rule_buf
[rule_pos
++] = (char) p2
;
19760 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19761 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19762 p1
= get_random_num (0, sizeof (grp_pos
));
19763 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19764 p2
= get_random_num (0, sizeof (grp_pos
));
19766 p2
= get_random_num (0, sizeof (grp_pos
));
19767 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19771 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19772 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19773 p1
= get_random_num (0, sizeof (grp_pos
));
19774 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19775 p2
= get_random_num (1, sizeof (grp_pos
));
19777 p2
= get_random_num (1, sizeof (grp_pos
));
19778 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19782 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19783 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19784 p1
= get_random_num (0, sizeof (grp_pos
));
19785 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19786 p2
= get_random_num (1, sizeof (grp_pos
));
19787 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19788 p3
= get_random_num (0, sizeof (grp_pos
));
19789 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19797 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19799 char mem
[BLOCK_SIZE
];
19801 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19803 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19805 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19807 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19809 int out_len
= in_len
;
19810 int mem_len
= in_len
;
19812 memcpy (out
, in
, out_len
);
19816 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19818 int upos
; int upos2
;
19821 switch (rule
[rule_pos
])
19826 case RULE_OP_MANGLE_NOOP
:
19829 case RULE_OP_MANGLE_LREST
:
19830 out_len
= mangle_lrest (out
, out_len
);
19833 case RULE_OP_MANGLE_UREST
:
19834 out_len
= mangle_urest (out
, out_len
);
19837 case RULE_OP_MANGLE_LREST_UFIRST
:
19838 out_len
= mangle_lrest (out
, out_len
);
19839 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19842 case RULE_OP_MANGLE_UREST_LFIRST
:
19843 out_len
= mangle_urest (out
, out_len
);
19844 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19847 case RULE_OP_MANGLE_TREST
:
19848 out_len
= mangle_trest (out
, out_len
);
19851 case RULE_OP_MANGLE_TOGGLE_AT
:
19852 NEXT_RULEPOS (rule_pos
);
19853 NEXT_RPTOI (rule
, rule_pos
, upos
);
19854 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19857 case RULE_OP_MANGLE_REVERSE
:
19858 out_len
= mangle_reverse (out
, out_len
);
19861 case RULE_OP_MANGLE_DUPEWORD
:
19862 out_len
= mangle_double (out
, out_len
);
19865 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19866 NEXT_RULEPOS (rule_pos
);
19867 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19868 out_len
= mangle_double_times (out
, out_len
, ulen
);
19871 case RULE_OP_MANGLE_REFLECT
:
19872 out_len
= mangle_reflect (out
, out_len
);
19875 case RULE_OP_MANGLE_ROTATE_LEFT
:
19876 mangle_rotate_left (out
, out_len
);
19879 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19880 mangle_rotate_right (out
, out_len
);
19883 case RULE_OP_MANGLE_APPEND
:
19884 NEXT_RULEPOS (rule_pos
);
19885 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19888 case RULE_OP_MANGLE_PREPEND
:
19889 NEXT_RULEPOS (rule_pos
);
19890 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19893 case RULE_OP_MANGLE_DELETE_FIRST
:
19894 out_len
= mangle_delete_at (out
, out_len
, 0);
19897 case RULE_OP_MANGLE_DELETE_LAST
:
19898 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19901 case RULE_OP_MANGLE_DELETE_AT
:
19902 NEXT_RULEPOS (rule_pos
);
19903 NEXT_RPTOI (rule
, rule_pos
, upos
);
19904 out_len
= mangle_delete_at (out
, out_len
, upos
);
19907 case RULE_OP_MANGLE_EXTRACT
:
19908 NEXT_RULEPOS (rule_pos
);
19909 NEXT_RPTOI (rule
, rule_pos
, upos
);
19910 NEXT_RULEPOS (rule_pos
);
19911 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19912 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19915 case RULE_OP_MANGLE_OMIT
:
19916 NEXT_RULEPOS (rule_pos
);
19917 NEXT_RPTOI (rule
, rule_pos
, upos
);
19918 NEXT_RULEPOS (rule_pos
);
19919 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19920 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19923 case RULE_OP_MANGLE_INSERT
:
19924 NEXT_RULEPOS (rule_pos
);
19925 NEXT_RPTOI (rule
, rule_pos
, upos
);
19926 NEXT_RULEPOS (rule_pos
);
19927 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19930 case RULE_OP_MANGLE_OVERSTRIKE
:
19931 NEXT_RULEPOS (rule_pos
);
19932 NEXT_RPTOI (rule
, rule_pos
, upos
);
19933 NEXT_RULEPOS (rule_pos
);
19934 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
19937 case RULE_OP_MANGLE_TRUNCATE_AT
:
19938 NEXT_RULEPOS (rule_pos
);
19939 NEXT_RPTOI (rule
, rule_pos
, upos
);
19940 out_len
= mangle_truncate_at (out
, out_len
, upos
);
19943 case RULE_OP_MANGLE_REPLACE
:
19944 NEXT_RULEPOS (rule_pos
);
19945 NEXT_RULEPOS (rule_pos
);
19946 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
19949 case RULE_OP_MANGLE_PURGECHAR
:
19950 NEXT_RULEPOS (rule_pos
);
19951 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
19954 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19958 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19959 NEXT_RULEPOS (rule_pos
);
19960 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19961 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
19964 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19965 NEXT_RULEPOS (rule_pos
);
19966 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19967 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
19970 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19971 out_len
= mangle_dupechar (out
, out_len
);
19974 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19975 NEXT_RULEPOS (rule_pos
);
19976 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19977 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
19980 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19981 NEXT_RULEPOS (rule_pos
);
19982 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19983 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
19986 case RULE_OP_MANGLE_SWITCH_FIRST
:
19987 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
19990 case RULE_OP_MANGLE_SWITCH_LAST
:
19991 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
19994 case RULE_OP_MANGLE_SWITCH_AT
:
19995 NEXT_RULEPOS (rule_pos
);
19996 NEXT_RPTOI (rule
, rule_pos
, upos
);
19997 NEXT_RULEPOS (rule_pos
);
19998 NEXT_RPTOI (rule
, rule_pos
, upos2
);
19999 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20002 case RULE_OP_MANGLE_CHR_SHIFTL
:
20003 NEXT_RULEPOS (rule_pos
);
20004 NEXT_RPTOI (rule
, rule_pos
, upos
);
20005 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20008 case RULE_OP_MANGLE_CHR_SHIFTR
:
20009 NEXT_RULEPOS (rule_pos
);
20010 NEXT_RPTOI (rule
, rule_pos
, upos
);
20011 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20014 case RULE_OP_MANGLE_CHR_INCR
:
20015 NEXT_RULEPOS (rule_pos
);
20016 NEXT_RPTOI (rule
, rule_pos
, upos
);
20017 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20020 case RULE_OP_MANGLE_CHR_DECR
:
20021 NEXT_RULEPOS (rule_pos
);
20022 NEXT_RPTOI (rule
, rule_pos
, upos
);
20023 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20026 case RULE_OP_MANGLE_REPLACE_NP1
:
20027 NEXT_RULEPOS (rule_pos
);
20028 NEXT_RPTOI (rule
, rule_pos
, upos
);
20029 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20032 case RULE_OP_MANGLE_REPLACE_NM1
:
20033 NEXT_RULEPOS (rule_pos
);
20034 NEXT_RPTOI (rule
, rule_pos
, upos
);
20035 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20038 case RULE_OP_MANGLE_TITLE
:
20039 out_len
= mangle_title (out
, out_len
);
20042 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20043 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20044 NEXT_RULEPOS (rule_pos
);
20045 NEXT_RPTOI (rule
, rule_pos
, upos
);
20046 NEXT_RULEPOS (rule_pos
);
20047 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20048 NEXT_RULEPOS (rule_pos
);
20049 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20050 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20053 case RULE_OP_MANGLE_APPEND_MEMORY
:
20054 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20055 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20056 memcpy (out
+ out_len
, mem
, mem_len
);
20057 out_len
+= mem_len
;
20060 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20061 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20062 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20063 memcpy (mem
+ mem_len
, out
, out_len
);
20064 out_len
+= mem_len
;
20065 memcpy (out
, mem
, out_len
);
20068 case RULE_OP_MEMORIZE_WORD
:
20069 memcpy (mem
, out
, out_len
);
20073 case RULE_OP_REJECT_LESS
:
20074 NEXT_RULEPOS (rule_pos
);
20075 NEXT_RPTOI (rule
, rule_pos
, upos
);
20076 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20079 case RULE_OP_REJECT_GREATER
:
20080 NEXT_RULEPOS (rule_pos
);
20081 NEXT_RPTOI (rule
, rule_pos
, upos
);
20082 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20085 case RULE_OP_REJECT_CONTAIN
:
20086 NEXT_RULEPOS (rule_pos
);
20087 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20090 case RULE_OP_REJECT_NOT_CONTAIN
:
20091 NEXT_RULEPOS (rule_pos
);
20092 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20095 case RULE_OP_REJECT_EQUAL_FIRST
:
20096 NEXT_RULEPOS (rule_pos
);
20097 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20100 case RULE_OP_REJECT_EQUAL_LAST
:
20101 NEXT_RULEPOS (rule_pos
);
20102 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20105 case RULE_OP_REJECT_EQUAL_AT
:
20106 NEXT_RULEPOS (rule_pos
);
20107 NEXT_RPTOI (rule
, rule_pos
, upos
);
20108 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20109 NEXT_RULEPOS (rule_pos
);
20110 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20113 case RULE_OP_REJECT_CONTAINS
:
20114 NEXT_RULEPOS (rule_pos
);
20115 NEXT_RPTOI (rule
, rule_pos
, upos
);
20116 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20117 NEXT_RULEPOS (rule_pos
);
20118 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20119 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20122 case RULE_OP_REJECT_MEMORY
:
20123 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20127 return (RULE_RC_SYNTAX_ERROR
);
20132 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);