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;
5581 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5582 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5585 return ((char *) "Unknown");
5588 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5590 uint hash_type
= data
.hash_type
;
5591 uint hash_mode
= data
.hash_mode
;
5592 uint salt_type
= data
.salt_type
;
5593 uint opts_type
= data
.opts_type
;
5594 uint opti_type
= data
.opti_type
;
5595 uint dgst_size
= data
.dgst_size
;
5597 char *hashfile
= data
.hashfile
;
5601 uint digest_buf
[64];
5603 uint64_t *digest_buf64
= (uint64_t *) digest_buf
;
5605 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5607 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5609 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5615 case HASH_TYPE_DESCRYPT
:
5616 FP (digest_buf
[1], digest_buf
[0], tt
);
5619 case HASH_TYPE_DESRACF
:
5620 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5621 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5623 FP (digest_buf
[1], digest_buf
[0], tt
);
5627 FP (digest_buf
[1], digest_buf
[0], tt
);
5630 case HASH_TYPE_NETNTLM
:
5631 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 29);
5632 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 29);
5633 digest_buf
[2] = ROTATE_LEFT (digest_buf
[2], 29);
5634 digest_buf
[3] = ROTATE_LEFT (digest_buf
[3], 29);
5636 FP (digest_buf
[1], digest_buf
[0], tt
);
5637 FP (digest_buf
[3], digest_buf
[2], tt
);
5640 case HASH_TYPE_BSDICRYPT
:
5641 digest_buf
[0] = ROTATE_LEFT (digest_buf
[0], 31);
5642 digest_buf
[1] = ROTATE_LEFT (digest_buf
[1], 31);
5644 FP (digest_buf
[1], digest_buf
[0], tt
);
5649 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5654 digest_buf
[0] += MD4M_A
;
5655 digest_buf
[1] += MD4M_B
;
5656 digest_buf
[2] += MD4M_C
;
5657 digest_buf
[3] += MD4M_D
;
5661 digest_buf
[0] += MD5M_A
;
5662 digest_buf
[1] += MD5M_B
;
5663 digest_buf
[2] += MD5M_C
;
5664 digest_buf
[3] += MD5M_D
;
5667 case HASH_TYPE_SHA1
:
5668 digest_buf
[0] += SHA1M_A
;
5669 digest_buf
[1] += SHA1M_B
;
5670 digest_buf
[2] += SHA1M_C
;
5671 digest_buf
[3] += SHA1M_D
;
5672 digest_buf
[4] += SHA1M_E
;
5675 case HASH_TYPE_SHA256
:
5676 digest_buf
[0] += SHA256M_A
;
5677 digest_buf
[1] += SHA256M_B
;
5678 digest_buf
[2] += SHA256M_C
;
5679 digest_buf
[3] += SHA256M_D
;
5680 digest_buf
[4] += SHA256M_E
;
5681 digest_buf
[5] += SHA256M_F
;
5682 digest_buf
[6] += SHA256M_G
;
5683 digest_buf
[7] += SHA256M_H
;
5686 case HASH_TYPE_SHA384
:
5687 digest_buf64
[0] += SHA384M_A
;
5688 digest_buf64
[1] += SHA384M_B
;
5689 digest_buf64
[2] += SHA384M_C
;
5690 digest_buf64
[3] += SHA384M_D
;
5691 digest_buf64
[4] += SHA384M_E
;
5692 digest_buf64
[5] += SHA384M_F
;
5693 digest_buf64
[6] += 0;
5694 digest_buf64
[7] += 0;
5697 case HASH_TYPE_SHA512
:
5698 digest_buf64
[0] += SHA512M_A
;
5699 digest_buf64
[1] += SHA512M_B
;
5700 digest_buf64
[2] += SHA512M_C
;
5701 digest_buf64
[3] += SHA512M_D
;
5702 digest_buf64
[4] += SHA512M_E
;
5703 digest_buf64
[5] += SHA512M_F
;
5704 digest_buf64
[6] += SHA512M_G
;
5705 digest_buf64
[7] += SHA512M_H
;
5710 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5712 if (dgst_size
== DGST_SIZE_4_2
)
5714 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5716 else if (dgst_size
== DGST_SIZE_4_4
)
5718 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5720 else if (dgst_size
== DGST_SIZE_4_5
)
5722 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5724 else if (dgst_size
== DGST_SIZE_4_6
)
5726 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5728 else if (dgst_size
== DGST_SIZE_4_8
)
5730 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5732 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
5734 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
5736 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5738 else if (hash_type
== HASH_TYPE_SHA384
)
5740 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5742 else if (hash_type
== HASH_TYPE_SHA512
)
5744 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5746 else if (hash_type
== HASH_TYPE_GOST
)
5748 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5751 else if (dgst_size
== DGST_SIZE_4_64
)
5753 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5755 else if (dgst_size
== DGST_SIZE_8_25
)
5757 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
5761 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
5762 | (data
.salt_type
== SALT_TYPE_EXTERN
)
5763 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
5769 memset (&salt
, 0, sizeof (salt_t
));
5771 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
5773 char *ptr
= (char *) salt
.salt_buf
;
5775 uint len
= salt
.salt_len
;
5777 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5783 case HASH_TYPE_NETNTLM
:
5785 salt
.salt_buf
[0] = ROTATE_RIGHT (salt
.salt_buf
[0], 3);
5786 salt
.salt_buf
[1] = ROTATE_RIGHT (salt
.salt_buf
[1], 3);
5788 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
5794 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
5796 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5804 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
5806 uint max
= salt
.salt_len
/ 4;
5810 for (uint i
= 0; i
< max
; i
++)
5812 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
5816 if (opts_type
& OPTS_TYPE_ST_HEX
)
5820 memset (tmp
, 0, sizeof (tmp
));
5822 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
5824 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
5829 memcpy (ptr
, tmp
, len
);
5832 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
5834 memset (ptr
+ len
, 0, memset_size
);
5836 salt
.salt_len
= len
;
5840 // some modes require special encoding
5843 uint out_buf_plain
[256];
5844 uint out_buf_salt
[256];
5848 memset (out_buf_plain
, 0, sizeof (out_buf_plain
));
5849 memset (out_buf_salt
, 0, sizeof (out_buf_salt
));
5851 memset (tmp_buf
, 0, sizeof (tmp_buf
));
5853 char *ptr_plain
= (char *) out_buf_plain
;
5854 char *ptr_salt
= (char *) out_buf_salt
;
5856 if (hash_mode
== 22)
5860 memset (username
, 0, sizeof (username
));
5862 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
5864 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
5866 uint16_t *ptr
= (uint16_t *) digest_buf
;
5868 tmp_buf
[ 0] = sig
[0];
5869 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
5870 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
5871 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
5872 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
5873 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
5874 tmp_buf
[ 6] = sig
[1];
5875 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
5876 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
5877 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
5878 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
5879 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
5880 tmp_buf
[12] = sig
[2];
5881 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
5882 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
5883 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
5884 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
5885 tmp_buf
[17] = sig
[3];
5886 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
5887 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
5888 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
5889 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
5890 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
5891 tmp_buf
[23] = sig
[4];
5892 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
5893 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
5894 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
5895 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
5896 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
5897 tmp_buf
[29] = sig
[5];
5899 snprintf (out_buf
, len
-1, "%s:%s",
5903 else if (hash_mode
== 23)
5905 // do not show the \nskyper\n part in output
5907 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
5909 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
5911 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
5918 else if (hash_mode
== 101)
5920 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5922 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5923 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5924 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5925 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5926 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5928 memcpy (tmp_buf
, digest_buf
, 20);
5930 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
5932 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
5934 else if (hash_mode
== 111)
5936 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5938 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5939 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5940 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5941 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
5942 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
5944 memcpy (tmp_buf
, digest_buf
, 20);
5945 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
5947 base64_encode (int_to_base64
, tmp_buf
, 20 + salt
.salt_len
, ptr_plain
);
5949 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
5951 else if (hash_mode
== 122)
5953 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
5954 (unsigned char *) salt
.salt_buf
,
5961 else if (hash_mode
== 124)
5963 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
5964 (unsigned char *) salt
.salt_buf
,
5971 else if (hash_mode
== 131)
5973 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
5974 (unsigned char *) salt
.salt_buf
,
5982 else if (hash_mode
== 132)
5984 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
5985 (unsigned char *) salt
.salt_buf
,
5992 else if (hash_mode
== 133)
5994 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
5996 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
5997 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
5998 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
5999 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6000 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6002 memcpy (tmp_buf
, digest_buf
, 20);
6004 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6006 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6008 else if (hash_mode
== 141)
6010 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6012 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6014 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6016 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6018 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6019 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6020 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6021 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6022 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6024 memcpy (tmp_buf
, digest_buf
, 20);
6026 base64_encode (int_to_base64
, tmp_buf
, 20, ptr_plain
);
6030 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6032 else if (hash_mode
== 400)
6034 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6036 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6037 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6038 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6039 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6041 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6043 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6045 else if (hash_mode
== 500)
6047 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6049 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6050 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6051 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6052 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6054 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6056 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6058 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6062 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6065 else if (hash_mode
== 501)
6067 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6069 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6070 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6072 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6074 else if (hash_mode
== 1421)
6076 uint8_t *salt_ptr
= (uint8_t *) salt
.salt_buf
;
6078 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6094 else if (hash_mode
== 1441)
6096 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6098 base64_encode (int_to_base64
, tmp_buf
, salt
.salt_len
, ptr_salt
);
6100 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6102 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6104 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6105 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6106 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6107 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6108 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6109 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6110 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6111 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6113 memcpy (tmp_buf
, digest_buf
, 32);
6115 base64_encode (int_to_base64
, tmp_buf
, 32, ptr_plain
);
6119 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6121 else if (hash_mode
== 1500)
6123 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6124 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6125 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6126 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6127 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6129 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6131 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6133 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6134 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6136 memcpy (tmp_buf
, digest_buf
, 8);
6138 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
6140 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6144 else if (hash_mode
== 1600)
6146 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6148 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6149 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6150 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6151 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6153 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6155 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6157 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6161 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6164 else if (hash_mode
== 1711)
6166 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6168 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6169 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6170 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6171 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6172 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6173 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6174 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6175 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6177 memcpy (tmp_buf
, digest_buf
, 64);
6178 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6180 base64_encode (int_to_base64
, tmp_buf
, 64 + salt
.salt_len
, ptr_plain
);
6182 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6184 else if (hash_mode
== 1722)
6186 uint
*ptr
= digest_buf
;
6188 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6189 (unsigned char *) salt
.salt_buf
,
6199 else if (hash_mode
== 1731)
6201 uint
*ptr
= digest_buf
;
6203 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6204 (unsigned char *) salt
.salt_buf
,
6214 else if (hash_mode
== 1800)
6218 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6219 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6220 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6221 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6222 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6223 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6224 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6225 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6227 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6229 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6231 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6235 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6238 else if (hash_mode
== 2100)
6242 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6244 salt
.salt_iter
+ 1);
6246 uint signature_len
= strlen (out_buf
);
6248 pos
+= signature_len
;
6249 len
-= signature_len
;
6251 char *salt_ptr
= (char *) salt
.salt_buf
;
6253 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6255 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6256 byte_swap_32 (digest_buf
[0]),
6257 byte_swap_32 (digest_buf
[1]),
6258 byte_swap_32 (digest_buf
[2]),
6259 byte_swap_32 (digest_buf
[3]));
6261 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6263 memcpy (tmp_buf
, digest_buf
, 16);
6265 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6267 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6268 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6269 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6270 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6272 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6273 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6274 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6275 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6277 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6278 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6279 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6280 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6282 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6283 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6284 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6285 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6287 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6288 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6289 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6290 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6294 else if (hash_mode
== 2500)
6296 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6298 wpa_t
*wpa
= &wpas
[salt_pos
];
6302 char *pke_ptr
= (char *) pke
;
6304 for (uint i
= 0; i
< 25; i
++)
6306 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6309 unsigned char mac1
[6];
6310 unsigned char mac2
[6];
6312 memcpy (mac1
, pke_ptr
+ 23, 6);
6313 memcpy (mac2
, pke_ptr
+ 29, 6);
6315 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6316 (char *) salt
.salt_buf
,
6330 else if (hash_mode
== 4400)
6332 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6333 byte_swap_32 (digest_buf
[0]),
6334 byte_swap_32 (digest_buf
[1]),
6335 byte_swap_32 (digest_buf
[2]),
6336 byte_swap_32 (digest_buf
[3]));
6338 else if (hash_mode
== 4700)
6340 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6341 byte_swap_32 (digest_buf
[0]),
6342 byte_swap_32 (digest_buf
[1]),
6343 byte_swap_32 (digest_buf
[2]),
6344 byte_swap_32 (digest_buf
[3]),
6345 byte_swap_32 (digest_buf
[4]));
6347 else if (hash_mode
== 4800)
6349 uint8_t chap_id_byte
= (uint8_t) salt
.salt_buf
[4];
6351 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6356 byte_swap_32 (salt
.salt_buf
[0]),
6357 byte_swap_32 (salt
.salt_buf
[1]),
6358 byte_swap_32 (salt
.salt_buf
[2]),
6359 byte_swap_32 (salt
.salt_buf
[3]),
6362 else if (hash_mode
== 4900)
6364 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6365 byte_swap_32 (digest_buf
[0]),
6366 byte_swap_32 (digest_buf
[1]),
6367 byte_swap_32 (digest_buf
[2]),
6368 byte_swap_32 (digest_buf
[3]),
6369 byte_swap_32 (digest_buf
[4]));
6371 else if (hash_mode
== 5100)
6373 snprintf (out_buf
, len
-1, "%08x%08x",
6377 else if (hash_mode
== 5200)
6379 snprintf (out_buf
, len
-1, "%s", hashfile
);
6381 else if (hash_mode
== 5300)
6383 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6385 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6387 int buf_len
= len
-1;
6391 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6393 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6395 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6397 snprintf (out_buf
, buf_len
, ":");
6403 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6411 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6413 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6415 if ((i
== 0) || (i
== 5))
6417 snprintf (out_buf
, buf_len
, ":");
6423 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6431 for (uint i
= 0; i
< 4; i
++)
6435 snprintf (out_buf
, buf_len
, ":");
6441 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6447 else if (hash_mode
== 5400)
6449 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6451 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6453 int buf_len
= len
-1;
6457 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6459 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6461 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6463 snprintf (out_buf
, buf_len
, ":");
6469 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6477 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6479 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6481 if ((i
== 0) || (i
== 5))
6483 snprintf (out_buf
, buf_len
, ":");
6489 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6497 for (uint i
= 0; i
< 5; i
++)
6501 snprintf (out_buf
, buf_len
, ":");
6507 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6513 else if (hash_mode
== 5500)
6515 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6517 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6520 char domain_buf
[64];
6521 char srvchall_buf
[1024];
6522 char clichall_buf
[1024];
6524 memset (user_buf
, 0, sizeof (user_buf
));
6525 memset (domain_buf
, 0, sizeof (domain_buf
));
6526 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6527 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6529 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6531 char *ptr
= (char *) netntlm
->userdomain_buf
;
6533 user_buf
[i
] = ptr
[j
];
6536 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6538 char *ptr
= (char *) netntlm
->userdomain_buf
;
6540 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6543 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6545 char *ptr
= (char *) netntlm
->chall_buf
;
6547 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6550 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6552 char *ptr
= (char *) netntlm
->chall_buf
;
6554 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6557 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6565 byte_swap_32 (salt
.salt_buf_pc
[0]),
6566 byte_swap_32 (salt
.salt_buf_pc
[1]),
6569 else if (hash_mode
== 5600)
6571 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6573 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6576 char domain_buf
[64];
6577 char srvchall_buf
[1024];
6578 char clichall_buf
[1024];
6580 memset (user_buf
, 0, sizeof (user_buf
));
6581 memset (domain_buf
, 0, sizeof (domain_buf
));
6582 memset (srvchall_buf
, 0, sizeof (srvchall_buf
));
6583 memset (clichall_buf
, 0, sizeof (clichall_buf
));
6585 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6587 char *ptr
= (char *) netntlm
->userdomain_buf
;
6589 user_buf
[i
] = ptr
[j
];
6592 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6594 char *ptr
= (char *) netntlm
->userdomain_buf
;
6596 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6599 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6601 char *ptr
= (char *) netntlm
->chall_buf
;
6603 sprintf (srvchall_buf
+ j
, "%02x", (uint8_t) ptr
[i
]);
6606 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6608 char *ptr
= (char *) netntlm
->chall_buf
;
6610 sprintf (clichall_buf
+ j
, "%02x", (uint8_t) ptr
[netntlm
->srvchall_len
+ i
]);
6613 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6623 else if (hash_mode
== 5700)
6625 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6627 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6628 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6629 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6630 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6631 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6632 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6633 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6634 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6636 memcpy (tmp_buf
, digest_buf
, 32);
6638 base64_encode (int_to_itoa64
, tmp_buf
, 32, ptr_plain
);
6642 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6644 else if (hash_mode
== 5800)
6646 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6647 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6648 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6649 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6650 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6652 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6659 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6661 snprintf (out_buf
, len
-1, "%s", hashfile
);
6663 else if (hash_mode
== 6300)
6665 // the encoder is a bit to intelligent, it expects the input data in the wrong BOM
6667 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6668 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6669 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6670 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6672 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6674 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6676 else if (hash_mode
== 6400)
6678 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6680 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6682 else if (hash_mode
== 6500)
6684 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6686 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6688 else if (hash_mode
== 6600)
6690 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6692 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6694 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6695 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6697 uint buf_len
= len
- 1;
6699 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6702 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6704 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6709 else if (hash_mode
== 6700)
6711 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6713 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6715 else if (hash_mode
== 6800)
6717 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6719 else if (hash_mode
== 7100)
6721 uint
*ptr
= digest_buf
;
6723 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6725 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6729 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6730 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6731 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6732 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6733 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6734 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6735 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6736 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6738 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",
6739 SIGNATURE_SHA512OSX
,
6741 esalt
[ 0], esalt
[ 1],
6742 esalt
[ 2], esalt
[ 3],
6743 esalt
[ 4], esalt
[ 5],
6744 esalt
[ 6], esalt
[ 7],
6752 ptr
[15], ptr
[14]);
6754 else if (hash_mode
== 7200)
6756 uint
*ptr
= digest_buf
;
6758 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6760 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6764 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
6766 len_used
= strlen (out_buf
);
6768 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
6770 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
6772 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
6775 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",
6783 ptr
[15], ptr
[14]);
6785 else if (hash_mode
== 7300)
6787 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
6789 rakp_t
*rakp
= &rakps
[salt_pos
];
6791 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
6793 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
6796 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
6803 else if (hash_mode
== 7400)
6805 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6807 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6808 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6809 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6810 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6811 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6812 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6813 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6814 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6816 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6818 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
6820 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6824 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6827 else if (hash_mode
== 7500)
6829 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
6831 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
6833 uint8_t *ptr_timestamp
= (uint8_t *) krb5pa
->timestamp
;
6834 uint8_t *ptr_checksum
= (uint8_t *) krb5pa
->checksum
;
6838 char *ptr_data
= data
;
6840 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
6842 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
6845 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
6847 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
6852 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
6854 (char *) krb5pa
->user
,
6855 (char *) krb5pa
->realm
,
6856 (char *) krb5pa
->salt
,
6859 else if (hash_mode
== 7700)
6861 snprintf (out_buf
, len
-1, "%s$%08X%08X",
6862 (char *) salt
.salt_buf
,
6866 else if (hash_mode
== 7800)
6868 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
6869 (char *) salt
.salt_buf
,
6876 else if (hash_mode
== 7900)
6878 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6882 char *tmp
= (char *) salt
.salt_buf_pc
;
6884 ptr_plain
[42] = tmp
[0];
6890 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6892 else if (hash_mode
== 8000)
6894 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
6895 (unsigned char *) salt
.salt_buf
,
6905 else if (hash_mode
== 8100)
6907 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6908 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6910 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
6911 (unsigned char *) salt
.salt_buf
,
6918 else if (hash_mode
== 8200)
6920 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
6922 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
6924 char data_buf
[4096];
6926 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
6928 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
6931 data_buf
[cloudkey
->data_len
* 2] = 0;
6933 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6934 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6935 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6936 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6937 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6938 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6939 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6940 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6942 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6943 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6944 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
6945 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
6947 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
6963 else if (hash_mode
== 8300)
6967 char digest_buf_c
[33];
6969 base32_encode (int_to_itoa32
, (char *) digest_buf
, 32, digest_buf_c
);
6971 digest_buf_c
[32] = 0;
6975 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
6977 char domain_buf_c
[33];
6979 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
6981 for (uint i
= 0; i
< salt_pc_len
; i
++)
6983 const char next
= domain_buf_c
[i
];
6985 domain_buf_c
[i
] = '.';
6990 domain_buf_c
[salt_pc_len
] = 0;
6994 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
6996 else if (hash_mode
== 8500)
6998 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7000 else if (hash_mode
== 2612)
7002 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7004 (char *) salt
.salt_buf
,
7010 else if (hash_mode
== 3711)
7012 char *salt_ptr
= (char *) salt
.salt_buf
;
7014 salt_ptr
[salt
.salt_len
- 1] = 0;
7016 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7017 SIGNATURE_MEDIAWIKI_B
,
7024 else if (hash_mode
== 8800)
7026 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7028 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7032 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7034 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7039 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7040 SIGNATURE_ANDROIDFDE
,
7041 byte_swap_32 (salt
.salt_buf
[0]),
7042 byte_swap_32 (salt
.salt_buf
[1]),
7043 byte_swap_32 (salt
.salt_buf
[2]),
7044 byte_swap_32 (salt
.salt_buf
[3]),
7045 byte_swap_32 (digest_buf
[0]),
7046 byte_swap_32 (digest_buf
[1]),
7047 byte_swap_32 (digest_buf
[2]),
7048 byte_swap_32 (digest_buf
[3]),
7051 else if (hash_mode
== 8900)
7053 uint N
= salt
.scrypt_N
;
7054 uint r
= salt
.scrypt_r
;
7055 uint p
= salt
.scrypt_p
;
7057 char base64_salt
[32];
7059 memset (base64_salt
, 0, 32);
7061 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, base64_salt
+ 0);
7063 memset (tmp_buf
, 0, 46);
7065 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7066 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7067 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7068 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7069 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7070 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7071 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7072 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7073 digest_buf
[8] = 0; // needed for base64_encode ()
7075 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
+ 0);
7077 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7085 else if (hash_mode
== 9000)
7087 snprintf (out_buf
, len
-1, "%s", hashfile
);
7089 else if (hash_mode
== 9200)
7093 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7095 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7097 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7101 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7102 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7103 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7104 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7105 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7106 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7107 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7108 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7109 digest_buf
[8] = 0; // needed for base64_encode ()
7112 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7114 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7115 tmp_buf
[43] = 0; // cut it here
7119 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7121 else if (hash_mode
== 9300)
7123 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7124 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7125 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7126 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7127 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7128 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7129 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7130 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7131 digest_buf
[8] = 0; // needed for base64_encode ()
7134 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7136 base64_encode (int_to_itoa64
, (char *) digest_buf
, 32, tmp_buf
);
7137 tmp_buf
[43] = 0; // cut it here
7139 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7141 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7143 else if (hash_mode
== 9400)
7145 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7147 office2007_t
*office2007
= &office2007s
[salt_pos
];
7149 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7150 SIGNATURE_OFFICE2007
,
7153 office2007
->keySize
,
7159 office2007
->encryptedVerifier
[0],
7160 office2007
->encryptedVerifier
[1],
7161 office2007
->encryptedVerifier
[2],
7162 office2007
->encryptedVerifier
[3],
7163 office2007
->encryptedVerifierHash
[0],
7164 office2007
->encryptedVerifierHash
[1],
7165 office2007
->encryptedVerifierHash
[2],
7166 office2007
->encryptedVerifierHash
[3],
7167 office2007
->encryptedVerifierHash
[4]);
7169 else if (hash_mode
== 9500)
7171 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7173 office2010_t
*office2010
= &office2010s
[salt_pos
];
7175 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,
7181 office2010
->encryptedVerifier
[0],
7182 office2010
->encryptedVerifier
[1],
7183 office2010
->encryptedVerifier
[2],
7184 office2010
->encryptedVerifier
[3],
7185 office2010
->encryptedVerifierHash
[0],
7186 office2010
->encryptedVerifierHash
[1],
7187 office2010
->encryptedVerifierHash
[2],
7188 office2010
->encryptedVerifierHash
[3],
7189 office2010
->encryptedVerifierHash
[4],
7190 office2010
->encryptedVerifierHash
[5],
7191 office2010
->encryptedVerifierHash
[6],
7192 office2010
->encryptedVerifierHash
[7]);
7194 else if (hash_mode
== 9600)
7196 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7198 office2013_t
*office2013
= &office2013s
[salt_pos
];
7200 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7206 office2013
->encryptedVerifier
[0],
7207 office2013
->encryptedVerifier
[1],
7208 office2013
->encryptedVerifier
[2],
7209 office2013
->encryptedVerifier
[3],
7210 office2013
->encryptedVerifierHash
[0],
7211 office2013
->encryptedVerifierHash
[1],
7212 office2013
->encryptedVerifierHash
[2],
7213 office2013
->encryptedVerifierHash
[3],
7214 office2013
->encryptedVerifierHash
[4],
7215 office2013
->encryptedVerifierHash
[5],
7216 office2013
->encryptedVerifierHash
[6],
7217 office2013
->encryptedVerifierHash
[7]);
7219 else if (hash_mode
== 9700)
7221 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7223 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7225 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7226 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7227 byte_swap_32 (salt
.salt_buf
[0]),
7228 byte_swap_32 (salt
.salt_buf
[1]),
7229 byte_swap_32 (salt
.salt_buf
[2]),
7230 byte_swap_32 (salt
.salt_buf
[3]),
7231 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7232 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7233 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7234 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7235 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7236 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7237 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7238 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7240 else if (hash_mode
== 9710)
7242 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7244 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7246 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7247 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7248 byte_swap_32 (salt
.salt_buf
[0]),
7249 byte_swap_32 (salt
.salt_buf
[1]),
7250 byte_swap_32 (salt
.salt_buf
[2]),
7251 byte_swap_32 (salt
.salt_buf
[3]),
7252 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7253 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7254 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7255 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7256 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7257 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7258 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7259 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7261 else if (hash_mode
== 9720)
7263 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7265 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7267 uint8_t *rc4key
= (uint8_t *) oldoffice01
->rc4key
;
7269 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7270 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7271 byte_swap_32 (salt
.salt_buf
[0]),
7272 byte_swap_32 (salt
.salt_buf
[1]),
7273 byte_swap_32 (salt
.salt_buf
[2]),
7274 byte_swap_32 (salt
.salt_buf
[3]),
7275 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7276 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7277 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7278 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7279 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7280 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7281 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7282 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7289 else if (hash_mode
== 9800)
7291 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7293 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7295 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7296 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7301 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7302 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7303 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7304 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7305 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7306 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7307 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7308 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7309 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7311 else if (hash_mode
== 9810)
7313 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7315 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7317 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7318 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7323 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7324 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7325 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7326 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7327 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7328 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7329 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7330 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7331 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7333 else if (hash_mode
== 9820)
7335 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7337 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7339 uint8_t *rc4key
= (uint8_t *) oldoffice34
->rc4key
;
7341 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7342 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7347 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7348 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7349 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7350 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7351 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7352 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7353 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7354 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7355 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7362 else if (hash_mode
== 10000)
7366 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7368 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7370 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7374 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7375 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7376 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7377 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7378 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7379 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7380 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7381 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7382 digest_buf
[8] = 0; // needed for base64_encode ()
7385 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7387 base64_encode (int_to_base64
, (char *) digest_buf
, 32, tmp_buf
);
7391 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7393 else if (hash_mode
== 10100)
7395 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7400 byte_swap_32 (salt
.salt_buf
[0]),
7401 byte_swap_32 (salt
.salt_buf
[1]),
7402 byte_swap_32 (salt
.salt_buf
[2]),
7403 byte_swap_32 (salt
.salt_buf
[3]));
7405 else if (hash_mode
== 10200)
7407 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7409 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7413 char challenge
[100];
7415 memset (challenge
, 0, sizeof (challenge
));
7417 base64_encode (int_to_base64
, (char *) salt
.salt_buf
, salt
.salt_len
, challenge
);
7423 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7424 (char *) cram_md5
->user
,
7432 memset (response
, 0, sizeof (response
));
7434 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, response
);
7436 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7438 else if (hash_mode
== 10300)
7442 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7444 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7445 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7447 uint tmp_len
= 20 + salt
.salt_len
;
7451 char base64_encoded
[100];
7453 memset (base64_encoded
, 0, sizeof (base64_encoded
));
7455 base64_encode (int_to_base64
, (char *) tmp_buf
, tmp_len
, base64_encoded
);
7457 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7459 else if (hash_mode
== 10400)
7461 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7463 pdf_t
*pdf
= &pdfs
[salt_pos
];
7465 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",
7473 byte_swap_32 (pdf
->id_buf
[0]),
7474 byte_swap_32 (pdf
->id_buf
[1]),
7475 byte_swap_32 (pdf
->id_buf
[2]),
7476 byte_swap_32 (pdf
->id_buf
[3]),
7478 byte_swap_32 (pdf
->u_buf
[0]),
7479 byte_swap_32 (pdf
->u_buf
[1]),
7480 byte_swap_32 (pdf
->u_buf
[2]),
7481 byte_swap_32 (pdf
->u_buf
[3]),
7482 byte_swap_32 (pdf
->u_buf
[4]),
7483 byte_swap_32 (pdf
->u_buf
[5]),
7484 byte_swap_32 (pdf
->u_buf
[6]),
7485 byte_swap_32 (pdf
->u_buf
[7]),
7487 byte_swap_32 (pdf
->o_buf
[0]),
7488 byte_swap_32 (pdf
->o_buf
[1]),
7489 byte_swap_32 (pdf
->o_buf
[2]),
7490 byte_swap_32 (pdf
->o_buf
[3]),
7491 byte_swap_32 (pdf
->o_buf
[4]),
7492 byte_swap_32 (pdf
->o_buf
[5]),
7493 byte_swap_32 (pdf
->o_buf
[6]),
7494 byte_swap_32 (pdf
->o_buf
[7])
7497 else if (hash_mode
== 10410)
7499 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7501 pdf_t
*pdf
= &pdfs
[salt_pos
];
7503 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",
7511 byte_swap_32 (pdf
->id_buf
[0]),
7512 byte_swap_32 (pdf
->id_buf
[1]),
7513 byte_swap_32 (pdf
->id_buf
[2]),
7514 byte_swap_32 (pdf
->id_buf
[3]),
7516 byte_swap_32 (pdf
->u_buf
[0]),
7517 byte_swap_32 (pdf
->u_buf
[1]),
7518 byte_swap_32 (pdf
->u_buf
[2]),
7519 byte_swap_32 (pdf
->u_buf
[3]),
7520 byte_swap_32 (pdf
->u_buf
[4]),
7521 byte_swap_32 (pdf
->u_buf
[5]),
7522 byte_swap_32 (pdf
->u_buf
[6]),
7523 byte_swap_32 (pdf
->u_buf
[7]),
7525 byte_swap_32 (pdf
->o_buf
[0]),
7526 byte_swap_32 (pdf
->o_buf
[1]),
7527 byte_swap_32 (pdf
->o_buf
[2]),
7528 byte_swap_32 (pdf
->o_buf
[3]),
7529 byte_swap_32 (pdf
->o_buf
[4]),
7530 byte_swap_32 (pdf
->o_buf
[5]),
7531 byte_swap_32 (pdf
->o_buf
[6]),
7532 byte_swap_32 (pdf
->o_buf
[7])
7535 else if (hash_mode
== 10420)
7537 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7539 pdf_t
*pdf
= &pdfs
[salt_pos
];
7541 uint8_t *rc4key
= (uint8_t *) pdf
->rc4key
;
7543 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",
7551 byte_swap_32 (pdf
->id_buf
[0]),
7552 byte_swap_32 (pdf
->id_buf
[1]),
7553 byte_swap_32 (pdf
->id_buf
[2]),
7554 byte_swap_32 (pdf
->id_buf
[3]),
7556 byte_swap_32 (pdf
->u_buf
[0]),
7557 byte_swap_32 (pdf
->u_buf
[1]),
7558 byte_swap_32 (pdf
->u_buf
[2]),
7559 byte_swap_32 (pdf
->u_buf
[3]),
7560 byte_swap_32 (pdf
->u_buf
[4]),
7561 byte_swap_32 (pdf
->u_buf
[5]),
7562 byte_swap_32 (pdf
->u_buf
[6]),
7563 byte_swap_32 (pdf
->u_buf
[7]),
7565 byte_swap_32 (pdf
->o_buf
[0]),
7566 byte_swap_32 (pdf
->o_buf
[1]),
7567 byte_swap_32 (pdf
->o_buf
[2]),
7568 byte_swap_32 (pdf
->o_buf
[3]),
7569 byte_swap_32 (pdf
->o_buf
[4]),
7570 byte_swap_32 (pdf
->o_buf
[5]),
7571 byte_swap_32 (pdf
->o_buf
[6]),
7572 byte_swap_32 (pdf
->o_buf
[7]),
7580 else if (hash_mode
== 10500)
7582 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7584 pdf_t
*pdf
= &pdfs
[salt_pos
];
7586 if (pdf
->id_len
== 32)
7588 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",
7596 byte_swap_32 (pdf
->id_buf
[0]),
7597 byte_swap_32 (pdf
->id_buf
[1]),
7598 byte_swap_32 (pdf
->id_buf
[2]),
7599 byte_swap_32 (pdf
->id_buf
[3]),
7600 byte_swap_32 (pdf
->id_buf
[4]),
7601 byte_swap_32 (pdf
->id_buf
[5]),
7602 byte_swap_32 (pdf
->id_buf
[6]),
7603 byte_swap_32 (pdf
->id_buf
[7]),
7605 byte_swap_32 (pdf
->u_buf
[0]),
7606 byte_swap_32 (pdf
->u_buf
[1]),
7607 byte_swap_32 (pdf
->u_buf
[2]),
7608 byte_swap_32 (pdf
->u_buf
[3]),
7609 byte_swap_32 (pdf
->u_buf
[4]),
7610 byte_swap_32 (pdf
->u_buf
[5]),
7611 byte_swap_32 (pdf
->u_buf
[6]),
7612 byte_swap_32 (pdf
->u_buf
[7]),
7614 byte_swap_32 (pdf
->o_buf
[0]),
7615 byte_swap_32 (pdf
->o_buf
[1]),
7616 byte_swap_32 (pdf
->o_buf
[2]),
7617 byte_swap_32 (pdf
->o_buf
[3]),
7618 byte_swap_32 (pdf
->o_buf
[4]),
7619 byte_swap_32 (pdf
->o_buf
[5]),
7620 byte_swap_32 (pdf
->o_buf
[6]),
7621 byte_swap_32 (pdf
->o_buf
[7])
7626 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",
7634 byte_swap_32 (pdf
->id_buf
[0]),
7635 byte_swap_32 (pdf
->id_buf
[1]),
7636 byte_swap_32 (pdf
->id_buf
[2]),
7637 byte_swap_32 (pdf
->id_buf
[3]),
7639 byte_swap_32 (pdf
->u_buf
[0]),
7640 byte_swap_32 (pdf
->u_buf
[1]),
7641 byte_swap_32 (pdf
->u_buf
[2]),
7642 byte_swap_32 (pdf
->u_buf
[3]),
7643 byte_swap_32 (pdf
->u_buf
[4]),
7644 byte_swap_32 (pdf
->u_buf
[5]),
7645 byte_swap_32 (pdf
->u_buf
[6]),
7646 byte_swap_32 (pdf
->u_buf
[7]),
7648 byte_swap_32 (pdf
->o_buf
[0]),
7649 byte_swap_32 (pdf
->o_buf
[1]),
7650 byte_swap_32 (pdf
->o_buf
[2]),
7651 byte_swap_32 (pdf
->o_buf
[3]),
7652 byte_swap_32 (pdf
->o_buf
[4]),
7653 byte_swap_32 (pdf
->o_buf
[5]),
7654 byte_swap_32 (pdf
->o_buf
[6]),
7655 byte_swap_32 (pdf
->o_buf
[7])
7659 else if (hash_mode
== 10600)
7661 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7663 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7664 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7666 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7668 else if (hash_mode
== 10700)
7670 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7672 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7673 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7675 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7677 else if (hash_mode
== 10900)
7679 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7681 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7682 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7684 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7686 else if (hash_mode
== 11100)
7688 uint32_t salt_challenge
= salt
.salt_buf
[0];
7690 salt_challenge
= byte_swap_32 (salt_challenge
);
7692 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7694 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7695 SIGNATURE_POSTGRESQL_AUTH
,
7703 else if (hash_mode
== 11200)
7705 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7706 SIGNATURE_MYSQL_AUTH
,
7707 (unsigned char *) salt
.salt_buf
,
7714 else if (hash_mode
== 11300)
7716 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7718 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7720 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7721 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7722 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7724 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7725 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7726 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7728 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7730 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->cry_master_buf
;
7732 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7735 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7737 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->ckey_buf
;
7739 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7742 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7744 const uint8_t *ptr
= (const uint8_t *) bitcoin_wallet
->public_key_buf
;
7746 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7749 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7750 SIGNATURE_BITCOIN_WALLET
,
7754 (unsigned char *) salt
.salt_buf
,
7762 free (cry_master_buf
);
7764 free (public_key_buf
);
7766 else if (hash_mode
== 11400)
7768 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7770 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7771 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7773 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7775 else if (hash_mode
== 11600)
7777 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
7779 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
7781 const uint data_len
= seven_zip
->data_len
;
7783 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
7785 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
7787 const uint8_t *ptr
= (const uint8_t *) seven_zip
->data_buf
;
7789 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
7792 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
7793 SIGNATURE_SEVEN_ZIP
,
7797 (char *) seven_zip
->salt_buf
,
7799 seven_zip
->iv_buf
[0],
7800 seven_zip
->iv_buf
[1],
7801 seven_zip
->iv_buf
[2],
7802 seven_zip
->iv_buf
[3],
7804 seven_zip
->data_len
,
7805 seven_zip
->unpack_size
,
7810 else if (hash_mode
== 11700)
7812 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7822 else if (hash_mode
== 11800)
7824 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7842 else if (hash_mode
== 11900)
7844 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7846 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7847 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7849 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7851 else if (hash_mode
== 12000)
7853 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7855 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7856 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7858 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7860 else if (hash_mode
== 12100)
7862 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7864 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7865 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7867 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7869 else if (hash_mode
== 12200)
7871 uint
*ptr_digest
= digest_buf
;
7872 uint
*ptr_salt
= salt
.salt_buf
;
7874 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
7881 else if (hash_mode
== 12300)
7883 uint
*ptr_digest
= digest_buf
;
7884 uint
*ptr_salt
= salt
.salt_buf
;
7886 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",
7887 ptr_digest
[ 0], ptr_digest
[ 1],
7888 ptr_digest
[ 2], ptr_digest
[ 3],
7889 ptr_digest
[ 4], ptr_digest
[ 5],
7890 ptr_digest
[ 6], ptr_digest
[ 7],
7891 ptr_digest
[ 8], ptr_digest
[ 9],
7892 ptr_digest
[10], ptr_digest
[11],
7893 ptr_digest
[12], ptr_digest
[13],
7894 ptr_digest
[14], ptr_digest
[15],
7900 else if (hash_mode
== 12400)
7902 // encode iteration count
7906 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
7907 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
7908 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
7909 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
7914 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
7915 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
7916 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
7917 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
7922 memset (tmp_buf
, 0, sizeof (tmp_buf
));
7924 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7925 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7927 memcpy (tmp_buf
, digest_buf
, 8);
7929 base64_encode (int_to_itoa64
, tmp_buf
, 8, ptr_plain
);
7933 // fill the resulting buffer
7935 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
7937 else if (hash_mode
== 12500)
7939 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
7941 byte_swap_32 (salt
.salt_buf
[0]),
7942 byte_swap_32 (salt
.salt_buf
[1]),
7948 else if (hash_mode
== 12600)
7950 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
7951 digest_buf
[0] + salt
.salt_buf_pc
[0],
7952 digest_buf
[1] + salt
.salt_buf_pc
[1],
7953 digest_buf
[2] + salt
.salt_buf_pc
[2],
7954 digest_buf
[3] + salt
.salt_buf_pc
[3],
7955 digest_buf
[4] + salt
.salt_buf_pc
[4],
7956 digest_buf
[5] + salt
.salt_buf_pc
[5],
7957 digest_buf
[6] + salt
.salt_buf_pc
[6],
7958 digest_buf
[7] + salt
.salt_buf_pc
[7]);
7960 else if (hash_mode
== 12700)
7962 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7964 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7965 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7967 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7969 else if (hash_mode
== 12800)
7971 const uint8_t *ptr
= (const uint8_t *) salt
.salt_buf
;
7973 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",
7986 byte_swap_32 (digest_buf
[0]),
7987 byte_swap_32 (digest_buf
[1]),
7988 byte_swap_32 (digest_buf
[2]),
7989 byte_swap_32 (digest_buf
[3]),
7990 byte_swap_32 (digest_buf
[4]),
7991 byte_swap_32 (digest_buf
[5]),
7992 byte_swap_32 (digest_buf
[6]),
7993 byte_swap_32 (digest_buf
[7])
7998 if (hash_type
== HASH_TYPE_MD4
)
8000 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8006 else if (hash_type
== HASH_TYPE_MD5
)
8008 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8014 else if (hash_type
== HASH_TYPE_SHA1
)
8016 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8023 else if (hash_type
== HASH_TYPE_SHA256
)
8025 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8035 else if (hash_type
== HASH_TYPE_SHA384
)
8037 uint
*ptr
= digest_buf
;
8039 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8047 else if (hash_type
== HASH_TYPE_SHA512
)
8049 uint
*ptr
= digest_buf
;
8051 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8061 else if (hash_type
== HASH_TYPE_LM
)
8063 snprintf (out_buf
, len
-1, "%08x%08x",
8067 else if (hash_type
== HASH_TYPE_ORACLEH
)
8069 snprintf (out_buf
, len
-1, "%08X%08X",
8073 else if (hash_type
== HASH_TYPE_BCRYPT
)
8075 base64_encode (int_to_bf64
, (char *) salt
.salt_buf
, 16, tmp_buf
+ 0);
8076 base64_encode (int_to_bf64
, (char *) digest_buf
, 23, tmp_buf
+ 22);
8078 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8080 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8082 else if (hash_type
== HASH_TYPE_KECCAK
)
8084 uint
*ptr
= digest_buf
;
8086 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",
8114 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8116 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8118 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8125 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8127 digest_buf
[ 0] = digest_buf
[ 0];
8128 digest_buf
[ 1] = digest_buf
[ 1];
8129 digest_buf
[ 2] = digest_buf
[ 2];
8130 digest_buf
[ 3] = digest_buf
[ 3];
8131 digest_buf
[ 4] = digest_buf
[ 4];
8132 digest_buf
[ 5] = digest_buf
[ 5];
8133 digest_buf
[ 6] = digest_buf
[ 6];
8134 digest_buf
[ 7] = digest_buf
[ 7];
8135 digest_buf
[ 8] = digest_buf
[ 8];
8136 digest_buf
[ 9] = digest_buf
[ 9];
8137 digest_buf
[10] = digest_buf
[10];
8138 digest_buf
[11] = digest_buf
[11];
8139 digest_buf
[12] = digest_buf
[12];
8140 digest_buf
[13] = digest_buf
[13];
8141 digest_buf
[14] = digest_buf
[14];
8142 digest_buf
[15] = digest_buf
[15];
8144 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8162 else if (hash_type
== HASH_TYPE_GOST
)
8164 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8174 else if (hash_type
== HASH_TYPE_MYSQL
)
8176 snprintf (out_buf
, len
-1, "%08x%08x",
8180 else if (hash_type
== HASH_TYPE_LOTUS5
)
8182 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8188 else if (hash_type
== HASH_TYPE_LOTUS6
)
8190 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8191 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8192 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8193 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8197 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8198 memcpy (buf
+ 5, digest_buf
, 9);
8202 base64_encode (int_to_lotus64
, buf
, 14, tmp_buf
);
8204 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8207 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8209 else if (hash_type
== HASH_TYPE_LOTUS8
)
8213 memset (buf
, 0, sizeof (buf
));
8217 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8223 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8227 buf
[26] = salt
.salt_buf_pc
[0];
8228 buf
[27] = salt
.salt_buf_pc
[1];
8232 memcpy (buf
+ 28, digest_buf
, 8);
8234 base64_encode (int_to_lotus64
, buf
, 36, tmp_buf
);
8238 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8240 else if (hash_type
== HASH_TYPE_CRC32
)
8242 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8246 if (salt_type
== SALT_TYPE_INTERN
)
8248 size_t pos
= strlen (out_buf
);
8250 out_buf
[pos
] = data
.separator
;
8252 char *ptr
= (char *) salt
.salt_buf
;
8254 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8256 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8260 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8262 memset (hccap
, 0, sizeof (hccap_t
));
8264 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8266 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8268 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8269 wpa_t
*wpa
= &wpas
[salt_pos
];
8271 hccap
->keyver
= wpa
->keyver
;
8273 hccap
->eapol_size
= wpa
->eapol_size
;
8275 if (wpa
->keyver
!= 1)
8279 for (uint i
= 0; i
< 64; i
++)
8281 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8284 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8288 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8293 for (int i
= 5; i
< 25; i
++)
8295 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8298 char *pke_ptr
= (char *) pke_tmp
;
8300 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8301 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8302 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8303 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8305 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8307 uint dgst_size
= data
.dgst_size
;
8309 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8311 if (wpa
->keyver
!= 1)
8315 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8316 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8317 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8318 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8320 memcpy (hccap
->keymic
, digest_tmp
, 16);
8324 memcpy (hccap
->keymic
, digest_ptr
, 16);
8328 void SuspendThreads ()
8330 if (data
.devices_status
== STATUS_RUNNING
)
8332 hc_timer_set (&data
.timer_paused
);
8334 data
.devices_status
= STATUS_PAUSED
;
8336 log_info ("Paused");
8340 void ResumeThreads ()
8342 if (data
.devices_status
== STATUS_PAUSED
)
8346 hc_timer_get (data
.timer_paused
, ms_paused
);
8348 data
.ms_paused
+= ms_paused
;
8350 data
.devices_status
= STATUS_RUNNING
;
8352 log_info ("Resumed");
8358 if (data
.devices_status
!= STATUS_RUNNING
) return;
8360 data
.devices_status
= STATUS_BYPASS
;
8362 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8365 void stop_at_checkpoint ()
8367 if (data
.devices_status
!= STATUS_RUNNING
) return;
8369 // this feature only makes sense if --restore-disable was not specified
8371 if (data
.restore_disable
== 0)
8373 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8375 // save the current restore point value
8377 data
.checkpoint_cur_words
= get_lowest_words_done ();
8379 log_info ("Stop at next checkpoint");
8383 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8389 if (data
.devices_status
== STATUS_INIT
) return;
8390 if (data
.devices_status
== STATUS_STARTING
) return;
8392 data
.devices_status
= STATUS_ABORTED
;
8397 if (data
.devices_status
== STATUS_INIT
) return;
8398 if (data
.devices_status
== STATUS_STARTING
) return;
8400 data
.devices_status
= STATUS_QUIT
;
8404 uint
get_vliw_by_device_name (const char *device_name
)
8408 if (strcmp (device_name
, "Capeverde" ) == 0) vliw
= 1;
8409 if (strcmp (device_name
, "Pitcairn" ) == 0) vliw
= 1;
8410 if (strcmp (device_name
, "Tahiti" ) == 0) vliw
= 1;
8411 if (strcmp (device_name
, "ATI RV710" ) == 0) vliw
= 1;
8412 if (strcmp (device_name
, "ATI RV730" ) == 0) vliw
= 1;
8413 if (strcmp (device_name
, "ATI RV770" ) == 0) vliw
= 4;
8414 if (strcmp (device_name
, "Cayman" ) == 0) vliw
= 4;
8415 if (strcmp (device_name
, "Devastator" ) == 0) vliw
= 4;
8416 if (strcmp (device_name
, "Scrapper" ) == 0) vliw
= 4;
8417 if (strcmp (device_name
, "Barts" ) == 0) vliw
= 5;
8418 if (strcmp (device_name
, "BeaverCreek" ) == 0) vliw
= 5;
8419 if (strcmp (device_name
, "Caicos" ) == 0) vliw
= 5;
8420 if (strcmp (device_name
, "Cedar" ) == 0) vliw
= 5;
8421 if (strcmp (device_name
, "Cypress" ) == 0) vliw
= 5;
8422 if (strcmp (device_name
, "Juniper" ) == 0) vliw
= 5;
8423 if (strcmp (device_name
, "Loveland" ) == 0) vliw
= 5;
8424 if (strcmp (device_name
, "Redwood" ) == 0) vliw
= 5;
8425 if (strcmp (device_name
, "Turks" ) == 0) vliw
= 5;
8426 if (strcmp (device_name
, "WinterPark" ) == 0) vliw
= 5;
8427 if (strcmp (device_name
, "Oland" ) == 0) vliw
= 1;
8428 if (strcmp (device_name
, "Cats" ) == 0) vliw
= 1;
8429 if (strcmp (device_name
, "Raccoons" ) == 0) vliw
= 1;
8430 if (strcmp (device_name
, "Bonaire" ) == 0) vliw
= 1;
8431 if (strcmp (device_name
, "Hawaii" ) == 0) vliw
= 1;
8432 if (strcmp (device_name
, "Spectre" ) == 0) vliw
= 1;
8433 if (strcmp (device_name
, "Spooky" ) == 0) vliw
= 1;
8434 if (strcmp (device_name
, "Kalindi" ) == 0) vliw
= 1;
8435 if (strcmp (device_name
, "Hainan" ) == 0) vliw
= 1;
8436 if (strcmp (device_name
, "Iceland" ) == 0) vliw
= 1;
8437 if (strcmp (device_name
, "Tonga" ) == 0) vliw
= 1;
8438 if (strcmp (device_name
, "Mullins" ) == 0) vliw
= 1;
8439 if (strcmp (device_name
, "Fiji" ) == 0) vliw
= 1;
8441 if (strncmp (device_name
, "ATI Radeon HD 4", 15) == 0) vliw
= 1;
8442 if (strncmp (device_name
, "ATI Radeon HD 5", 15) == 0) vliw
= 5;
8443 if (strncmp (device_name
, "ATI Radeon HD 6", 15) == 0) vliw
= 4;
8444 if (strncmp (device_name
, "ATI Radeon HD 7", 15) == 0) vliw
= 4;
8445 if (strncmp (device_name
, "ATI Radeon HD 79", 16) == 0) vliw
= 1;
8446 if (strncmp (device_name
, "ATI Radeon HD 8", 15) == 0) vliw
= 1;
8447 if (strncmp (device_name
, "AMD Radeon R9", 13) == 0) vliw
= 1;
8452 uint
get_vliw_by_compute_capability (const uint major
, const uint minor
)
8456 if (major
== 1 && minor
== 0) vliw
= 1;
8457 if (major
== 1 && minor
== 1) vliw
= 1;
8458 if (major
== 1 && minor
== 2) vliw
= 1;
8459 if (major
== 1 && minor
== 3) vliw
= 1;
8460 if (major
== 2 && minor
== 0) vliw
= 1;
8461 if (major
== 2 && minor
== 1) vliw
= 2;
8462 if (major
== 3 && minor
== 0) vliw
= 2;
8463 if (major
== 3 && minor
== 5) vliw
= 2;
8464 if (major
== 3 && minor
== 7) vliw
= 2;
8465 if (major
== 5 && minor
== 0) vliw
= 2;
8466 if (major
== 5 && minor
== 2) vliw
= 2;
8473 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8477 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8481 memset (&st
, 0, sizeof (st
));
8483 stat (kernel_file
, &st
);
8485 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8487 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8489 if (num_read
!= (size_t) st
.st_size
)
8491 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8498 buf
[st
.st_size
] = 0;
8500 for (int i
= 0; i
< num_devices
; i
++)
8502 kernel_lengths
[i
] = (size_t) st
.st_size
;
8504 kernel_sources
[i
] = buf
;
8509 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8517 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8519 FILE *fp
= fopen (dst
, "wb");
8521 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8532 restore_data_t
*init_restore (int argc
, char **argv
)
8534 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8536 if (data
.restore_disable
== 0)
8538 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8542 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8546 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8555 char pidbin
[BUFSIZ
];
8560 memset (pidbin
, 0, sizeof (pidbin
));
8562 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8564 FILE *fd
= fopen (pidbin
, "rb");
8568 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8570 pidbin
[pidbin_len
] = 0;
8574 char *argv0_r
= strrchr (argv
[0], '/');
8576 char *pidbin_r
= strrchr (pidbin
, '/');
8578 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8580 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8582 if (strcmp (argv0_r
, pidbin_r
) == 0)
8584 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8591 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8593 char pidbin2
[BUFSIZ
];
8597 memset (pidbin2
, 0, sizeof (pidbin2
));
8599 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8600 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8602 pidbin
[pidbin_len
] = 0;
8603 pidbin2
[pidbin2_len
] = 0;
8607 if (strcmp (pidbin
, pidbin2
) == 0)
8609 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8617 if (rd
->version_bin
< RESTORE_MIN
)
8619 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8626 memset (rd
, 0, sizeof (restore_data_t
));
8628 rd
->version_bin
= VERSION_BIN
;
8631 rd
->pid
= getpid ();
8633 rd
->pid
= GetCurrentProcessId ();
8636 if (getcwd (rd
->cwd
, 255) == NULL
)
8649 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8651 FILE *fp
= fopen (eff_restore_file
, "rb");
8655 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8660 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8662 log_error ("ERROR: cannot read %s", eff_restore_file
);
8667 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8669 for (uint i
= 0; i
< rd
->argc
; i
++)
8673 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8675 log_error ("ERROR: cannot read %s", eff_restore_file
);
8680 size_t len
= strlen (buf
);
8682 if (len
) buf
[len
- 1] = 0;
8684 rd
->argv
[i
] = mystrdup (buf
);
8691 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8695 log_error ("Restore file is corrupted");
8698 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8700 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8702 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8707 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8711 if (chdir (rd
->cwd
))
8713 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8719 uint64_t get_lowest_words_done ()
8721 uint64_t words_cur
= -1;
8723 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8725 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8727 const uint64_t words_done
= device_param
->words_done
;
8729 if (words_done
< words_cur
) words_cur
= words_done
;
8735 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8737 uint64_t words_cur
= get_lowest_words_done ();
8739 rd
->words_cur
= words_cur
;
8741 FILE *fp
= fopen (new_restore_file
, "wb");
8745 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8750 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8752 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8757 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8759 for (uint i
= 0; i
< rd
->argc
; i
++)
8761 fprintf (fp
, "%s", rd
->argv
[i
]);
8767 fsync (fileno (fp
));
8772 void cycle_restore ()
8774 const char *eff_restore_file
= data
.eff_restore_file
;
8775 const char *new_restore_file
= data
.new_restore_file
;
8777 restore_data_t
*rd
= data
.rd
;
8779 write_restore (new_restore_file
, rd
);
8783 memset (&st
, 0, sizeof(st
));
8785 if (stat (eff_restore_file
, &st
) == 0)
8787 if (unlink (eff_restore_file
))
8789 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8793 if (rename (new_restore_file
, eff_restore_file
))
8795 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8799 void check_checkpoint ()
8801 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8803 uint64_t words_cur
= get_lowest_words_done ();
8805 if (words_cur
!= data
.checkpoint_cur_words
)
8815 uint
set_gpu_accel (uint hash_mode
)
8819 case 0: return GET_ACCEL (0);
8820 case 10: return GET_ACCEL (10);
8821 case 11: return GET_ACCEL (11);
8822 case 12: return GET_ACCEL (12);
8823 case 20: return GET_ACCEL (20);
8824 case 21: return GET_ACCEL (21);
8825 case 22: return GET_ACCEL (22);
8826 case 23: return GET_ACCEL (23);
8827 case 30: return GET_ACCEL (30);
8828 case 40: return GET_ACCEL (40);
8829 case 50: return GET_ACCEL (50);
8830 case 60: return GET_ACCEL (60);
8831 case 100: return GET_ACCEL (100);
8832 case 101: return GET_ACCEL (101);
8833 case 110: return GET_ACCEL (110);
8834 case 111: return GET_ACCEL (111);
8835 case 112: return GET_ACCEL (112);
8836 case 120: return GET_ACCEL (120);
8837 case 121: return GET_ACCEL (121);
8838 case 122: return GET_ACCEL (122);
8839 case 124: return GET_ACCEL (124);
8840 case 130: return GET_ACCEL (130);
8841 case 131: return GET_ACCEL (131);
8842 case 132: return GET_ACCEL (132);
8843 case 133: return GET_ACCEL (133);
8844 case 140: return GET_ACCEL (140);
8845 case 141: return GET_ACCEL (141);
8846 case 150: return GET_ACCEL (150);
8847 case 160: return GET_ACCEL (160);
8848 case 190: return GET_ACCEL (190);
8849 case 200: return GET_ACCEL (200);
8850 case 300: return GET_ACCEL (300);
8851 case 400: return GET_ACCEL (400);
8852 case 500: return GET_ACCEL (500);
8853 case 501: return GET_ACCEL (501);
8854 case 900: return GET_ACCEL (900);
8855 case 910: return GET_ACCEL (910);
8856 case 1000: return GET_ACCEL (1000);
8857 case 1100: return GET_ACCEL (1100);
8858 case 1400: return GET_ACCEL (1400);
8859 case 1410: return GET_ACCEL (1410);
8860 case 1420: return GET_ACCEL (1420);
8861 case 1421: return GET_ACCEL (1421);
8862 case 1430: return GET_ACCEL (1430);
8863 case 1440: return GET_ACCEL (1440);
8864 case 1441: return GET_ACCEL (1441);
8865 case 1450: return GET_ACCEL (1450);
8866 case 1460: return GET_ACCEL (1460);
8867 case 1500: return GET_ACCEL (1500);
8868 case 1600: return GET_ACCEL (1600);
8869 case 1700: return GET_ACCEL (1700);
8870 case 1710: return GET_ACCEL (1710);
8871 case 1711: return GET_ACCEL (1711);
8872 case 1720: return GET_ACCEL (1720);
8873 case 1722: return GET_ACCEL (1722);
8874 case 1730: return GET_ACCEL (1730);
8875 case 1731: return GET_ACCEL (1731);
8876 case 1740: return GET_ACCEL (1740);
8877 case 1750: return GET_ACCEL (1750);
8878 case 1760: return GET_ACCEL (1760);
8879 case 1800: return GET_ACCEL (1800);
8880 case 2100: return GET_ACCEL (2100);
8881 case 2400: return GET_ACCEL (2400);
8882 case 2410: return GET_ACCEL (2410);
8883 case 2500: return GET_ACCEL (2500);
8884 case 2600: return GET_ACCEL (2600);
8885 case 2611: return GET_ACCEL (2611);
8886 case 2612: return GET_ACCEL (2612);
8887 case 2711: return GET_ACCEL (2711);
8888 case 2811: return GET_ACCEL (2811);
8889 case 3000: return GET_ACCEL (3000);
8890 case 3100: return GET_ACCEL (3100);
8891 case 3200: return GET_ACCEL (3200);
8892 case 3710: return GET_ACCEL (3710);
8893 case 3711: return GET_ACCEL (3711);
8894 case 3800: return GET_ACCEL (3800);
8895 case 4300: return GET_ACCEL (4300);
8896 case 4400: return GET_ACCEL (4400);
8897 case 4500: return GET_ACCEL (4500);
8898 case 4700: return GET_ACCEL (4700);
8899 case 4800: return GET_ACCEL (4800);
8900 case 4900: return GET_ACCEL (4900);
8901 case 5000: return GET_ACCEL (5000);
8902 case 5100: return GET_ACCEL (5100);
8903 case 5200: return GET_ACCEL (5200);
8904 case 5300: return GET_ACCEL (5300);
8905 case 5400: return GET_ACCEL (5400);
8906 case 5500: return GET_ACCEL (5500);
8907 case 5600: return GET_ACCEL (5600);
8908 case 5700: return GET_ACCEL (5700);
8909 case 5800: return GET_ACCEL (5800);
8910 case 6000: return GET_ACCEL (6000);
8911 case 6100: return GET_ACCEL (6100);
8912 case 6211: return GET_ACCEL (6211);
8913 case 6212: return GET_ACCEL (6212);
8914 case 6213: return GET_ACCEL (6213);
8915 case 6221: return GET_ACCEL (6221);
8916 case 6222: return GET_ACCEL (6222);
8917 case 6223: return GET_ACCEL (6223);
8918 case 6231: return GET_ACCEL (6231);
8919 case 6232: return GET_ACCEL (6232);
8920 case 6233: return GET_ACCEL (6233);
8921 case 6241: return GET_ACCEL (6241);
8922 case 6242: return GET_ACCEL (6242);
8923 case 6243: return GET_ACCEL (6243);
8924 case 6300: return GET_ACCEL (6300);
8925 case 6400: return GET_ACCEL (6400);
8926 case 6500: return GET_ACCEL (6500);
8927 case 6600: return GET_ACCEL (6600);
8928 case 6700: return GET_ACCEL (6700);
8929 case 6800: return GET_ACCEL (6800);
8930 case 6900: return GET_ACCEL (6900);
8931 case 7100: return GET_ACCEL (7100);
8932 case 7200: return GET_ACCEL (7200);
8933 case 7300: return GET_ACCEL (7300);
8934 case 7400: return GET_ACCEL (7400);
8935 case 7500: return GET_ACCEL (7500);
8936 case 7600: return GET_ACCEL (7600);
8937 case 7700: return GET_ACCEL (7700);
8938 case 7800: return GET_ACCEL (7800);
8939 case 7900: return GET_ACCEL (7900);
8940 case 8000: return GET_ACCEL (8000);
8941 case 8100: return GET_ACCEL (8100);
8942 case 8200: return GET_ACCEL (8200);
8943 case 8300: return GET_ACCEL (8300);
8944 case 8400: return GET_ACCEL (8400);
8945 case 8500: return GET_ACCEL (8500);
8946 case 8600: return GET_ACCEL (8600);
8947 case 8700: return GET_ACCEL (8700);
8948 case 8800: return GET_ACCEL (8800);
8949 case 8900: return GET_ACCEL (8900);
8950 case 9000: return GET_ACCEL (9000);
8951 case 9100: return GET_ACCEL (9100);
8952 case 9200: return GET_ACCEL (9200);
8953 case 9300: return GET_ACCEL (9300);
8954 case 9400: return GET_ACCEL (9400);
8955 case 9500: return GET_ACCEL (9500);
8956 case 9600: return GET_ACCEL (9600);
8957 case 9700: return GET_ACCEL (9700);
8958 case 9710: return GET_ACCEL (9710);
8959 case 9720: return GET_ACCEL (9720);
8960 case 9800: return GET_ACCEL (9800);
8961 case 9810: return GET_ACCEL (9810);
8962 case 9820: return GET_ACCEL (9820);
8963 case 9900: return GET_ACCEL (9900);
8964 case 10000: return GET_ACCEL (10000);
8965 case 10100: return GET_ACCEL (10100);
8966 case 10200: return GET_ACCEL (10200);
8967 case 10300: return GET_ACCEL (10300);
8968 case 10400: return GET_ACCEL (10400);
8969 case 10410: return GET_ACCEL (10410);
8970 case 10420: return GET_ACCEL (10420);
8971 case 10500: return GET_ACCEL (10500);
8972 case 10600: return GET_ACCEL (10600);
8973 case 10700: return GET_ACCEL (10700);
8974 case 10800: return GET_ACCEL (10800);
8975 case 10900: return GET_ACCEL (10900);
8976 case 11000: return GET_ACCEL (11000);
8977 case 11100: return GET_ACCEL (11100);
8978 case 11200: return GET_ACCEL (11200);
8979 case 11300: return GET_ACCEL (11300);
8980 case 11400: return GET_ACCEL (11400);
8981 case 11500: return GET_ACCEL (11500);
8982 case 11600: return GET_ACCEL (11600);
8983 case 11700: return GET_ACCEL (11700);
8984 case 11800: return GET_ACCEL (11800);
8985 case 11900: return GET_ACCEL (11900);
8986 case 12000: return GET_ACCEL (12000);
8987 case 12100: return GET_ACCEL (12100);
8988 case 12200: return GET_ACCEL (12200);
8989 case 12300: return GET_ACCEL (12300);
8990 case 12400: return GET_ACCEL (12400);
8991 case 12500: return GET_ACCEL (12500);
8992 case 12600: return GET_ACCEL (12600);
8993 case 12700: return GET_ACCEL (12700);
8994 case 12800: return GET_ACCEL (12800);
9000 uint
set_gpu_loops (uint hash_mode
)
9004 case 0: return GET_LOOPS (0);
9005 case 10: return GET_LOOPS (10);
9006 case 11: return GET_LOOPS (11);
9007 case 12: return GET_LOOPS (12);
9008 case 20: return GET_LOOPS (20);
9009 case 21: return GET_LOOPS (21);
9010 case 22: return GET_LOOPS (22);
9011 case 23: return GET_LOOPS (23);
9012 case 30: return GET_LOOPS (30);
9013 case 40: return GET_LOOPS (40);
9014 case 50: return GET_LOOPS (50);
9015 case 60: return GET_LOOPS (60);
9016 case 100: return GET_LOOPS (100);
9017 case 101: return GET_LOOPS (101);
9018 case 110: return GET_LOOPS (110);
9019 case 111: return GET_LOOPS (111);
9020 case 112: return GET_LOOPS (112);
9021 case 120: return GET_LOOPS (120);
9022 case 121: return GET_LOOPS (121);
9023 case 122: return GET_LOOPS (122);
9024 case 124: return GET_LOOPS (124);
9025 case 130: return GET_LOOPS (130);
9026 case 131: return GET_LOOPS (131);
9027 case 132: return GET_LOOPS (132);
9028 case 133: return GET_LOOPS (133);
9029 case 140: return GET_LOOPS (140);
9030 case 141: return GET_LOOPS (141);
9031 case 150: return GET_LOOPS (150);
9032 case 160: return GET_LOOPS (160);
9033 case 190: return GET_LOOPS (190);
9034 case 200: return GET_LOOPS (200);
9035 case 300: return GET_LOOPS (300);
9036 case 400: return GET_LOOPS (400);
9037 case 500: return GET_LOOPS (500);
9038 case 501: return GET_LOOPS (501);
9039 case 900: return GET_LOOPS (900);
9040 case 910: return GET_LOOPS (910);
9041 case 1000: return GET_LOOPS (1000);
9042 case 1100: return GET_LOOPS (1100);
9043 case 1400: return GET_LOOPS (1400);
9044 case 1410: return GET_LOOPS (1410);
9045 case 1420: return GET_LOOPS (1420);
9046 case 1421: return GET_LOOPS (1421);
9047 case 1430: return GET_LOOPS (1430);
9048 case 1440: return GET_LOOPS (1440);
9049 case 1441: return GET_LOOPS (1441);
9050 case 1450: return GET_LOOPS (1450);
9051 case 1460: return GET_LOOPS (1460);
9052 case 1500: return GET_LOOPS (1500);
9053 case 1600: return GET_LOOPS (1600);
9054 case 1700: return GET_LOOPS (1700);
9055 case 1710: return GET_LOOPS (1710);
9056 case 1711: return GET_LOOPS (1711);
9057 case 1720: return GET_LOOPS (1720);
9058 case 1722: return GET_LOOPS (1722);
9059 case 1730: return GET_LOOPS (1730);
9060 case 1731: return GET_LOOPS (1731);
9061 case 1740: return GET_LOOPS (1740);
9062 case 1750: return GET_LOOPS (1750);
9063 case 1760: return GET_LOOPS (1760);
9064 case 1800: return GET_LOOPS (1800);
9065 case 2100: return GET_LOOPS (2100);
9066 case 2400: return GET_LOOPS (2400);
9067 case 2410: return GET_LOOPS (2410);
9068 case 2500: return GET_LOOPS (2500);
9069 case 2600: return GET_LOOPS (2600);
9070 case 2611: return GET_LOOPS (2611);
9071 case 2612: return GET_LOOPS (2612);
9072 case 2711: return GET_LOOPS (2711);
9073 case 2811: return GET_LOOPS (2811);
9074 case 3000: return GET_LOOPS (3000);
9075 case 3100: return GET_LOOPS (3100);
9076 case 3200: return GET_LOOPS (3200);
9077 case 3710: return GET_LOOPS (3710);
9078 case 3711: return GET_LOOPS (3711);
9079 case 3800: return GET_LOOPS (3800);
9080 case 4300: return GET_LOOPS (4300);
9081 case 4400: return GET_LOOPS (4400);
9082 case 4500: return GET_LOOPS (4500);
9083 case 4700: return GET_LOOPS (4700);
9084 case 4800: return GET_LOOPS (4800);
9085 case 4900: return GET_LOOPS (4900);
9086 case 5000: return GET_LOOPS (5000);
9087 case 5100: return GET_LOOPS (5100);
9088 case 5200: return GET_LOOPS (5200);
9089 case 5300: return GET_LOOPS (5300);
9090 case 5400: return GET_LOOPS (5400);
9091 case 5500: return GET_LOOPS (5500);
9092 case 5600: return GET_LOOPS (5600);
9093 case 5700: return GET_LOOPS (5700);
9094 case 5800: return GET_LOOPS (5800);
9095 case 6000: return GET_LOOPS (6000);
9096 case 6100: return GET_LOOPS (6100);
9097 case 6211: return GET_LOOPS (6211);
9098 case 6212: return GET_LOOPS (6212);
9099 case 6213: return GET_LOOPS (6213);
9100 case 6221: return GET_LOOPS (6221);
9101 case 6222: return GET_LOOPS (6222);
9102 case 6223: return GET_LOOPS (6223);
9103 case 6231: return GET_LOOPS (6231);
9104 case 6232: return GET_LOOPS (6232);
9105 case 6233: return GET_LOOPS (6233);
9106 case 6241: return GET_LOOPS (6241);
9107 case 6242: return GET_LOOPS (6242);
9108 case 6243: return GET_LOOPS (6243);
9109 case 6300: return GET_LOOPS (6300);
9110 case 6400: return GET_LOOPS (6400);
9111 case 6500: return GET_LOOPS (6500);
9112 case 6600: return GET_LOOPS (6600);
9113 case 6700: return GET_LOOPS (6700);
9114 case 6800: return GET_LOOPS (6800);
9115 case 6900: return GET_LOOPS (6900);
9116 case 7100: return GET_LOOPS (7100);
9117 case 7200: return GET_LOOPS (7200);
9118 case 7300: return GET_LOOPS (7300);
9119 case 7400: return GET_LOOPS (7400);
9120 case 7500: return GET_LOOPS (7500);
9121 case 7600: return GET_LOOPS (7600);
9122 case 7700: return GET_LOOPS (7700);
9123 case 7800: return GET_LOOPS (7800);
9124 case 7900: return GET_LOOPS (7900);
9125 case 8000: return GET_LOOPS (8000);
9126 case 8100: return GET_LOOPS (8100);
9127 case 8200: return GET_LOOPS (8200);
9128 case 8300: return GET_LOOPS (8300);
9129 case 8400: return GET_LOOPS (8400);
9130 case 8500: return GET_LOOPS (8500);
9131 case 8600: return GET_LOOPS (8600);
9132 case 8700: return GET_LOOPS (8700);
9133 case 8800: return GET_LOOPS (8800);
9134 case 8900: return GET_LOOPS (8900);
9135 case 9000: return GET_LOOPS (9000);
9136 case 9100: return GET_LOOPS (9100);
9137 case 9200: return GET_LOOPS (9200);
9138 case 9300: return GET_LOOPS (9300);
9139 case 9400: return GET_LOOPS (9400);
9140 case 9500: return GET_LOOPS (9500);
9141 case 9600: return GET_LOOPS (9600);
9142 case 9700: return GET_LOOPS (9700);
9143 case 9710: return GET_LOOPS (9710);
9144 case 9720: return GET_LOOPS (9720);
9145 case 9800: return GET_LOOPS (9800);
9146 case 9810: return GET_LOOPS (9810);
9147 case 9820: return GET_LOOPS (9820);
9148 case 9900: return GET_LOOPS (9900);
9149 case 10000: return GET_LOOPS (10000);
9150 case 10100: return GET_LOOPS (10100);
9151 case 10200: return GET_LOOPS (10200);
9152 case 10300: return GET_LOOPS (10300);
9153 case 10400: return GET_LOOPS (10400);
9154 case 10410: return GET_LOOPS (10410);
9155 case 10420: return GET_LOOPS (10420);
9156 case 10500: return GET_LOOPS (10500);
9157 case 10600: return GET_LOOPS (10600);
9158 case 10700: return GET_LOOPS (10700);
9159 case 10800: return GET_LOOPS (10800);
9160 case 10900: return GET_LOOPS (10900);
9161 case 11000: return GET_LOOPS (11000);
9162 case 11100: return GET_LOOPS (11100);
9163 case 11200: return GET_LOOPS (11200);
9164 case 11300: return GET_LOOPS (11300);
9165 case 11400: return GET_LOOPS (11400);
9166 case 11500: return GET_LOOPS (11500);
9167 case 11600: return GET_LOOPS (11600);
9168 case 11700: return GET_LOOPS (11700);
9169 case 11800: return GET_LOOPS (11800);
9170 case 11900: return GET_LOOPS (11900);
9171 case 12000: return GET_LOOPS (12000);
9172 case 12100: return GET_LOOPS (12100);
9173 case 12200: return GET_LOOPS (12200);
9174 case 12300: return GET_LOOPS (12300);
9175 case 12400: return GET_LOOPS (12400);
9176 case 12500: return GET_LOOPS (12500);
9177 case 12600: return GET_LOOPS (12600);
9178 case 12700: return GET_LOOPS (12700);
9179 case 12800: return GET_LOOPS (12800);
9189 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9193 if (salt_len
> sizeof(tmp
))
9198 memset (tmp
, 0, sizeof (tmp
));
9199 memcpy (tmp
, in
, salt_len
);
9201 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9203 if ((salt_len
% 2) == 0)
9205 uint new_salt_len
= salt_len
/ 2;
9207 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9209 char p0
= tmp
[j
+ 0];
9210 char p1
= tmp
[j
+ 1];
9212 tmp
[i
] = hex_convert (p1
) << 0;
9213 tmp
[i
] |= hex_convert (p0
) << 4;
9216 salt_len
= new_salt_len
;
9223 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9225 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9228 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9230 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9234 uint
*tmp_uint
= (uint
*) tmp
;
9236 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9237 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9238 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9239 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9240 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9241 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9242 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9243 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9244 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9245 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9247 salt_len
= salt_len
* 2;
9255 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9257 lowercase (tmp
, salt_len
);
9260 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9262 uppercase (tmp
, salt_len
);
9265 uint len
= salt_len
;
9267 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9272 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9277 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9279 uint
*tmp_uint
= (uint
*) tmp
;
9285 for (uint i
= 0; i
< max
; i
++)
9287 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9290 // Important: we may need to increase the length of memcpy since
9291 // we don't want to "loose" some swapped bytes (could happen if
9292 // they do not perfectly fit in the 4-byte blocks)
9293 // Memcpy does always copy the bytes in the BE order, but since
9294 // we swapped them, some important bytes could be in positions
9295 // we normally skip with the original len
9297 if (len
% 4) len
+= 4 - (len
% 4);
9300 memcpy (out
, tmp
, len
);
9305 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9307 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9309 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9311 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9313 salt_t
*salt
= hash_buf
->salt
;
9315 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9317 char *iter_pos
= input_buf
+ 4;
9319 salt
->salt_iter
= 1 << atoi (iter_pos
);
9321 char *salt_pos
= strchr (iter_pos
, '$');
9323 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9329 salt
->salt_len
= salt_len
;
9333 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9335 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9337 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9339 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9341 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9342 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9343 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9344 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9346 char *hash_pos
= salt_pos
+ 22;
9348 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9350 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9352 memcpy (digest
, tmp_buf
, 24);
9354 digest
[0] = byte_swap_32 (digest
[0]);
9355 digest
[1] = byte_swap_32 (digest
[1]);
9356 digest
[2] = byte_swap_32 (digest
[2]);
9357 digest
[3] = byte_swap_32 (digest
[3]);
9358 digest
[4] = byte_swap_32 (digest
[4]);
9359 digest
[5] = byte_swap_32 (digest
[5]);
9361 digest
[5] &= ~0xff; // its just 23 not 24 !
9366 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9368 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9370 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9374 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9376 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9378 memcpy (digest
, tmp_buf
, 32);
9380 digest
[0] = byte_swap_32 (digest
[0]);
9381 digest
[1] = byte_swap_32 (digest
[1]);
9382 digest
[2] = byte_swap_32 (digest
[2]);
9383 digest
[3] = byte_swap_32 (digest
[3]);
9384 digest
[4] = byte_swap_32 (digest
[4]);
9385 digest
[5] = byte_swap_32 (digest
[5]);
9386 digest
[6] = byte_swap_32 (digest
[6]);
9387 digest
[7] = byte_swap_32 (digest
[7]);
9389 digest
[0] -= SHA256M_A
;
9390 digest
[1] -= SHA256M_B
;
9391 digest
[2] -= SHA256M_C
;
9392 digest
[3] -= SHA256M_D
;
9393 digest
[4] -= SHA256M_E
;
9394 digest
[5] -= SHA256M_F
;
9395 digest
[6] -= SHA256M_G
;
9396 digest
[7] -= SHA256M_H
;
9401 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9403 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9405 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9407 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9408 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9410 digest
[0] = byte_swap_32 (digest
[0]);
9411 digest
[1] = byte_swap_32 (digest
[1]);
9415 IP (digest
[0], digest
[1], tt
);
9417 digest
[0] = digest
[0];
9418 digest
[1] = digest
[1];
9425 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9427 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9429 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9431 salt_t
*salt
= hash_buf
->salt
;
9433 char *hash_pos
= input_buf
+ 8;
9435 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9436 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9437 digest
[2] = hex_to_uint (&hash_pos
[16]);
9438 digest
[3] = hex_to_uint (&hash_pos
[24]);
9439 digest
[4] = hex_to_uint (&hash_pos
[32]);
9441 digest
[0] -= SHA1M_A
;
9442 digest
[1] -= SHA1M_B
;
9443 digest
[2] -= SHA1M_C
;
9444 digest
[3] -= SHA1M_D
;
9445 digest
[4] -= SHA1M_E
;
9449 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9451 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9453 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9455 salt
->salt_len
= salt_len
;
9460 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9462 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9464 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9466 salt_t
*salt
= hash_buf
->salt
;
9468 char *hash_pos
= input_buf
+ 8;
9470 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9471 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9472 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9473 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9474 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9475 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9476 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9477 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9479 digest
[0] -= SHA512M_A
;
9480 digest
[1] -= SHA512M_B
;
9481 digest
[2] -= SHA512M_C
;
9482 digest
[3] -= SHA512M_D
;
9483 digest
[4] -= SHA512M_E
;
9484 digest
[5] -= SHA512M_F
;
9485 digest
[6] -= SHA512M_G
;
9486 digest
[7] -= SHA512M_H
;
9490 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9492 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9494 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9496 salt
->salt_len
= salt_len
;
9501 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9503 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9505 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9509 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9512 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9514 salt_t
*salt
= hash_buf
->salt
;
9516 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9517 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9518 digest
[2] = hex_to_uint (&input_buf
[16]);
9519 digest
[3] = hex_to_uint (&input_buf
[24]);
9521 digest
[0] = byte_swap_32 (digest
[0]);
9522 digest
[1] = byte_swap_32 (digest
[1]);
9523 digest
[2] = byte_swap_32 (digest
[2]);
9524 digest
[3] = byte_swap_32 (digest
[3]);
9526 digest
[0] -= MD5M_A
;
9527 digest
[1] -= MD5M_B
;
9528 digest
[2] -= MD5M_C
;
9529 digest
[3] -= MD5M_D
;
9531 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9533 uint salt_len
= input_len
- 32 - 1;
9535 char *salt_buf
= input_buf
+ 32 + 1;
9537 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9539 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9541 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9543 salt
->salt_len
= salt_len
;
9548 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9550 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9552 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9556 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9561 char clean_input_buf
[32];
9563 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9564 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9566 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9570 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9576 clean_input_buf
[k
] = input_buf
[i
];
9584 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9586 salt_t
*salt
= hash_buf
->salt
;
9588 char a
, b
, c
, d
, e
, f
;
9590 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9591 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9592 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9593 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9594 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9595 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9597 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9598 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9600 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9601 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9602 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9603 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9604 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9605 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9607 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9608 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9610 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9611 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9612 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9613 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9614 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9615 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9617 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9618 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9620 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9621 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9622 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9623 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9624 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9625 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9627 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9628 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9630 digest
[0] = byte_swap_32 (digest
[0]);
9631 digest
[1] = byte_swap_32 (digest
[1]);
9632 digest
[2] = byte_swap_32 (digest
[2]);
9633 digest
[3] = byte_swap_32 (digest
[3]);
9635 digest
[0] -= MD5M_A
;
9636 digest
[1] -= MD5M_B
;
9637 digest
[2] -= MD5M_C
;
9638 digest
[3] -= MD5M_D
;
9640 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9642 uint salt_len
= input_len
- 30 - 1;
9644 char *salt_buf
= input_buf
+ 30 + 1;
9646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9652 salt
->salt_len
= salt_len
;
9654 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9656 salt
->salt_len
+= 22;
9661 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9663 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9665 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9669 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9672 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9674 salt_t
*salt
= hash_buf
->salt
;
9676 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9677 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9678 digest
[2] = hex_to_uint (&input_buf
[16]);
9679 digest
[3] = hex_to_uint (&input_buf
[24]);
9680 digest
[4] = hex_to_uint (&input_buf
[32]);
9682 digest
[0] -= SHA1M_A
;
9683 digest
[1] -= SHA1M_B
;
9684 digest
[2] -= SHA1M_C
;
9685 digest
[3] -= SHA1M_D
;
9686 digest
[4] -= SHA1M_E
;
9688 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9690 uint salt_len
= input_len
- 40 - 1;
9692 char *salt_buf
= input_buf
+ 40 + 1;
9694 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9696 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9698 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9700 salt
->salt_len
= salt_len
;
9705 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9707 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9709 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9713 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9716 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9718 char *iter_pos
= input_buf
+ 6;
9720 salt_t
*salt
= hash_buf
->salt
;
9722 salt
->salt_iter
= atoi (iter_pos
) - 1;
9724 char *salt_pos
= strchr (iter_pos
, '#');
9726 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9730 char *digest_pos
= strchr (salt_pos
, '#');
9732 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9736 uint salt_len
= digest_pos
- salt_pos
- 1;
9738 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9740 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9741 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9742 digest
[2] = hex_to_uint (&digest_pos
[16]);
9743 digest
[3] = hex_to_uint (&digest_pos
[24]);
9745 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9747 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9749 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9751 salt
->salt_len
= salt_len
;
9756 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9758 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9760 salt_t
*salt
= hash_buf
->salt
;
9762 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9766 memcpy (&in
, input_buf
, input_len
);
9768 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9770 memcpy (digest
, in
.keymic
, 16);
9773 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9774 The phrase "Pairwise key expansion"
9775 Access Point Address (Referred to as Authenticator Address AA)
9776 Supplicant Address (referred to as Supplicant Address SA)
9777 Access Point Nonce (referred to as Authenticator Anonce)
9778 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9781 uint salt_len
= strlen (in
.essid
);
9783 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9785 salt
->salt_len
= salt_len
;
9787 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9789 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9791 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9793 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9795 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9796 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9800 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9801 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9804 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9806 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9807 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9811 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9812 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9815 for (int i
= 0; i
< 25; i
++)
9817 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9820 wpa
->keyver
= in
.keyver
;
9822 if (wpa
->keyver
> 255)
9824 log_info ("ATTENTION!");
9825 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9826 log_info (" This could be due to a recent aircrack-ng bug.");
9827 log_info (" The key version was automatically reset to a reasonable value.");
9830 wpa
->keyver
&= 0xff;
9833 wpa
->eapol_size
= in
.eapol_size
;
9835 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9837 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9839 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9841 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9843 if (wpa
->keyver
== 1)
9849 digest
[0] = byte_swap_32 (digest
[0]);
9850 digest
[1] = byte_swap_32 (digest
[1]);
9851 digest
[2] = byte_swap_32 (digest
[2]);
9852 digest
[3] = byte_swap_32 (digest
[3]);
9854 for (int i
= 0; i
< 64; i
++)
9856 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9860 salt
->salt_buf
[10] = digest
[1];
9861 salt
->salt_buf
[11] = digest
[2];
9866 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9868 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9870 salt_t
*salt
= hash_buf
->salt
;
9874 log_error ("Password Safe v2 container not specified");
9879 FILE *fp
= fopen (input_buf
, "rb");
9883 log_error ("%s: %s", input_buf
, strerror (errno
));
9892 uint32_t salt
[5]; // unused, but makes better valid check
9893 uint32_t iv
[2]; // unused, but makes better valid check
9899 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9903 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9905 salt
->salt_buf
[0] = buf
.random
[0];
9906 salt
->salt_buf
[1] = buf
.random
[1];
9909 salt
->salt_iter
= 1000;
9911 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9912 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9913 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9914 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9915 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9920 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9922 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9924 salt_t
*salt
= hash_buf
->salt
;
9928 log_error (".psafe3 not specified");
9933 FILE *fp
= fopen (input_buf
, "rb");
9937 log_error ("%s: %s", input_buf
, strerror (errno
));
9944 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9948 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9950 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9952 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9954 salt
->salt_iter
= in
.iterations
+ 1;
9956 salt
->salt_buf
[0] = in
.salt_buf
[0];
9957 salt
->salt_buf
[1] = in
.salt_buf
[1];
9958 salt
->salt_buf
[2] = in
.salt_buf
[2];
9959 salt
->salt_buf
[3] = in
.salt_buf
[3];
9960 salt
->salt_buf
[4] = in
.salt_buf
[4];
9961 salt
->salt_buf
[5] = in
.salt_buf
[5];
9962 salt
->salt_buf
[6] = in
.salt_buf
[6];
9963 salt
->salt_buf
[7] = in
.salt_buf
[7];
9965 salt
->salt_len
= 32;
9967 digest
[0] = in
.hash_buf
[0];
9968 digest
[1] = in
.hash_buf
[1];
9969 digest
[2] = in
.hash_buf
[2];
9970 digest
[3] = in
.hash_buf
[3];
9971 digest
[4] = in
.hash_buf
[4];
9972 digest
[5] = in
.hash_buf
[5];
9973 digest
[6] = in
.hash_buf
[6];
9974 digest
[7] = in
.hash_buf
[7];
9976 digest
[0] = byte_swap_32 (digest
[0]);
9977 digest
[1] = byte_swap_32 (digest
[1]);
9978 digest
[2] = byte_swap_32 (digest
[2]);
9979 digest
[3] = byte_swap_32 (digest
[3]);
9980 digest
[4] = byte_swap_32 (digest
[4]);
9981 digest
[5] = byte_swap_32 (digest
[5]);
9982 digest
[6] = byte_swap_32 (digest
[6]);
9983 digest
[7] = byte_swap_32 (digest
[7]);
9988 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9990 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
9992 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
9994 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9996 salt_t
*salt
= hash_buf
->salt
;
9998 char *iter_pos
= input_buf
+ 3;
10000 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10002 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10004 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10006 salt
->salt_iter
= salt_iter
;
10008 char *salt_pos
= iter_pos
+ 1;
10012 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10014 salt
->salt_len
= salt_len
;
10016 char *hash_pos
= salt_pos
+ salt_len
;
10018 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10020 return (PARSER_OK
);
10023 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10025 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10027 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10029 salt_t
*salt
= hash_buf
->salt
;
10031 char *salt_pos
= input_buf
+ 3;
10033 uint iterations_len
= 0;
10035 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10039 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10041 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10042 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10046 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10050 iterations_len
+= 8;
10054 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10057 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10059 char *hash_pos
= strchr (salt_pos
, '$');
10061 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10063 uint salt_len
= hash_pos
- salt_pos
;
10065 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10067 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10069 salt
->salt_len
= salt_len
;
10073 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10075 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10077 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10079 return (PARSER_OK
);
10082 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10084 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10086 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10088 salt_t
*salt
= hash_buf
->salt
;
10090 char *salt_pos
= input_buf
+ 6;
10092 uint iterations_len
= 0;
10094 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10098 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10100 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10101 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10105 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10109 iterations_len
+= 8;
10113 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10116 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10118 char *hash_pos
= strchr (salt_pos
, '$');
10120 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10122 uint salt_len
= hash_pos
- salt_pos
;
10124 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10126 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10128 salt
->salt_len
= salt_len
;
10132 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10134 return (PARSER_OK
);
10137 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10139 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10141 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10143 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10145 salt_t
*salt
= hash_buf
->salt
;
10147 char *salt_pos
= input_buf
+ 14;
10149 char *hash_pos
= strchr (salt_pos
, '*');
10151 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10155 uint salt_len
= hash_pos
- salt_pos
- 1;
10157 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10159 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10161 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10163 salt
->salt_len
= salt_len
;
10165 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10167 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10169 memcpy (digest
, tmp_buf
, 20);
10171 digest
[0] = byte_swap_32 (digest
[0]);
10172 digest
[1] = byte_swap_32 (digest
[1]);
10173 digest
[2] = byte_swap_32 (digest
[2]);
10174 digest
[3] = byte_swap_32 (digest
[3]);
10175 digest
[4] = byte_swap_32 (digest
[4]);
10177 digest
[0] -= SHA1M_A
;
10178 digest
[1] -= SHA1M_B
;
10179 digest
[2] -= SHA1M_C
;
10180 digest
[3] -= SHA1M_D
;
10181 digest
[4] -= SHA1M_E
;
10183 return (PARSER_OK
);
10186 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10188 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10190 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10192 if (c12
& 3) return (PARSER_HASH_VALUE
);
10194 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10196 salt_t
*salt
= hash_buf
->salt
;
10198 // for ascii_digest
10199 salt
->salt_sign
[0] = input_buf
[0];
10200 salt
->salt_sign
[1] = input_buf
[1];
10202 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10203 | itoa64_to_int (input_buf
[1]) << 6;
10205 salt
->salt_len
= 2;
10209 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10211 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10213 memcpy (digest
, tmp_buf
, 8);
10217 IP (digest
[0], digest
[1], tt
);
10222 return (PARSER_OK
);
10225 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10227 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10229 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10231 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10232 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10233 digest
[2] = hex_to_uint (&input_buf
[16]);
10234 digest
[3] = hex_to_uint (&input_buf
[24]);
10236 digest
[0] = byte_swap_32 (digest
[0]);
10237 digest
[1] = byte_swap_32 (digest
[1]);
10238 digest
[2] = byte_swap_32 (digest
[2]);
10239 digest
[3] = byte_swap_32 (digest
[3]);
10241 digest
[0] -= MD4M_A
;
10242 digest
[1] -= MD4M_B
;
10243 digest
[2] -= MD4M_C
;
10244 digest
[3] -= MD4M_D
;
10246 return (PARSER_OK
);
10249 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10251 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10253 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10257 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10260 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10262 salt_t
*salt
= hash_buf
->salt
;
10264 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10265 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10266 digest
[2] = hex_to_uint (&input_buf
[16]);
10267 digest
[3] = hex_to_uint (&input_buf
[24]);
10269 digest
[0] = byte_swap_32 (digest
[0]);
10270 digest
[1] = byte_swap_32 (digest
[1]);
10271 digest
[2] = byte_swap_32 (digest
[2]);
10272 digest
[3] = byte_swap_32 (digest
[3]);
10274 digest
[0] -= MD4M_A
;
10275 digest
[1] -= MD4M_B
;
10276 digest
[2] -= MD4M_C
;
10277 digest
[3] -= MD4M_D
;
10279 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10281 uint salt_len
= input_len
- 32 - 1;
10283 char *salt_buf
= input_buf
+ 32 + 1;
10285 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10287 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10289 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10291 salt
->salt_len
= salt_len
;
10293 return (PARSER_OK
);
10296 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10298 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10300 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10302 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10303 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10304 digest
[2] = hex_to_uint (&input_buf
[16]);
10305 digest
[3] = hex_to_uint (&input_buf
[24]);
10307 digest
[0] = byte_swap_32 (digest
[0]);
10308 digest
[1] = byte_swap_32 (digest
[1]);
10309 digest
[2] = byte_swap_32 (digest
[2]);
10310 digest
[3] = byte_swap_32 (digest
[3]);
10312 digest
[0] -= MD5M_A
;
10313 digest
[1] -= MD5M_B
;
10314 digest
[2] -= MD5M_C
;
10315 digest
[3] -= MD5M_D
;
10317 return (PARSER_OK
);
10320 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10322 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10324 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10326 digest
[0] = hex_to_uint (&input_buf
[0]);
10327 digest
[1] = hex_to_uint (&input_buf
[8]);
10331 digest
[0] = byte_swap_32 (digest
[0]);
10332 digest
[1] = byte_swap_32 (digest
[1]);
10334 return (PARSER_OK
);
10337 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10339 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10341 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10345 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10348 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10350 salt_t
*salt
= hash_buf
->salt
;
10352 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10353 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10354 digest
[2] = hex_to_uint (&input_buf
[16]);
10355 digest
[3] = hex_to_uint (&input_buf
[24]);
10357 digest
[0] = byte_swap_32 (digest
[0]);
10358 digest
[1] = byte_swap_32 (digest
[1]);
10359 digest
[2] = byte_swap_32 (digest
[2]);
10360 digest
[3] = byte_swap_32 (digest
[3]);
10362 digest
[0] -= MD5M_A
;
10363 digest
[1] -= MD5M_B
;
10364 digest
[2] -= MD5M_C
;
10365 digest
[3] -= MD5M_D
;
10367 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10369 uint salt_len
= input_len
- 32 - 1;
10371 char *salt_buf
= input_buf
+ 32 + 1;
10373 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10375 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10377 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10379 salt
->salt_len
= salt_len
;
10381 return (PARSER_OK
);
10384 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10386 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10388 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10390 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10391 | itoa64_to_int (input_buf
[ 1]) << 6
10392 | itoa64_to_int (input_buf
[ 2]) << 12
10393 | itoa64_to_int (input_buf
[ 3]) << 18;
10394 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10395 | itoa64_to_int (input_buf
[ 5]) << 6
10396 | itoa64_to_int (input_buf
[ 6]) << 12
10397 | itoa64_to_int (input_buf
[ 7]) << 18;
10398 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10399 | itoa64_to_int (input_buf
[ 9]) << 6
10400 | itoa64_to_int (input_buf
[10]) << 12
10401 | itoa64_to_int (input_buf
[11]) << 18;
10402 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10403 | itoa64_to_int (input_buf
[13]) << 6
10404 | itoa64_to_int (input_buf
[14]) << 12
10405 | itoa64_to_int (input_buf
[15]) << 18;
10407 digest
[0] -= MD5M_A
;
10408 digest
[1] -= MD5M_B
;
10409 digest
[2] -= MD5M_C
;
10410 digest
[3] -= MD5M_D
;
10412 digest
[0] &= 0x00ffffff;
10413 digest
[1] &= 0x00ffffff;
10414 digest
[2] &= 0x00ffffff;
10415 digest
[3] &= 0x00ffffff;
10417 return (PARSER_OK
);
10420 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10422 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10424 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10428 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10431 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10433 salt_t
*salt
= hash_buf
->salt
;
10435 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10436 | itoa64_to_int (input_buf
[ 1]) << 6
10437 | itoa64_to_int (input_buf
[ 2]) << 12
10438 | itoa64_to_int (input_buf
[ 3]) << 18;
10439 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10440 | itoa64_to_int (input_buf
[ 5]) << 6
10441 | itoa64_to_int (input_buf
[ 6]) << 12
10442 | itoa64_to_int (input_buf
[ 7]) << 18;
10443 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10444 | itoa64_to_int (input_buf
[ 9]) << 6
10445 | itoa64_to_int (input_buf
[10]) << 12
10446 | itoa64_to_int (input_buf
[11]) << 18;
10447 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10448 | itoa64_to_int (input_buf
[13]) << 6
10449 | itoa64_to_int (input_buf
[14]) << 12
10450 | itoa64_to_int (input_buf
[15]) << 18;
10452 digest
[0] -= MD5M_A
;
10453 digest
[1] -= MD5M_B
;
10454 digest
[2] -= MD5M_C
;
10455 digest
[3] -= MD5M_D
;
10457 digest
[0] &= 0x00ffffff;
10458 digest
[1] &= 0x00ffffff;
10459 digest
[2] &= 0x00ffffff;
10460 digest
[3] &= 0x00ffffff;
10462 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10464 uint salt_len
= input_len
- 16 - 1;
10466 char *salt_buf
= input_buf
+ 16 + 1;
10468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10470 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10472 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10474 salt
->salt_len
= salt_len
;
10476 return (PARSER_OK
);
10479 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10481 key
[0] = (nthash
[0] >> 0);
10482 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10483 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10484 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10485 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10486 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10487 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10488 key
[7] = (nthash
[6] << 1);
10500 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10502 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10504 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10506 salt_t
*salt
= hash_buf
->salt
;
10508 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10514 char *user_pos
= input_buf
;
10516 char *unused_pos
= strchr (user_pos
, ':');
10518 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10520 uint user_len
= unused_pos
- user_pos
;
10522 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10526 char *domain_pos
= strchr (unused_pos
, ':');
10528 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10530 uint unused_len
= domain_pos
- unused_pos
;
10532 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10536 char *srvchall_pos
= strchr (domain_pos
, ':');
10538 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10540 uint domain_len
= srvchall_pos
- domain_pos
;
10542 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10546 char *hash_pos
= strchr (srvchall_pos
, ':');
10548 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10550 uint srvchall_len
= hash_pos
- srvchall_pos
;
10552 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10556 char *clichall_pos
= strchr (hash_pos
, ':');
10558 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10560 uint hash_len
= clichall_pos
- hash_pos
;
10562 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10566 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10568 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10571 * store some data for later use
10574 netntlm
->user_len
= user_len
* 2;
10575 netntlm
->domain_len
= domain_len
* 2;
10576 netntlm
->srvchall_len
= srvchall_len
/ 2;
10577 netntlm
->clichall_len
= clichall_len
/ 2;
10579 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10580 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10583 * handle username and domainname
10586 for (uint i
= 0; i
< user_len
; i
++)
10588 *userdomain_ptr
++ = user_pos
[i
];
10589 *userdomain_ptr
++ = 0;
10592 for (uint i
= 0; i
< domain_len
; i
++)
10594 *userdomain_ptr
++ = domain_pos
[i
];
10595 *userdomain_ptr
++ = 0;
10599 * handle server challenge encoding
10602 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10604 const char p0
= srvchall_pos
[i
+ 0];
10605 const char p1
= srvchall_pos
[i
+ 1];
10607 *chall_ptr
++ = hex_convert (p1
) << 0
10608 | hex_convert (p0
) << 4;
10612 * handle client challenge encoding
10615 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10617 const char p0
= clichall_pos
[i
+ 0];
10618 const char p1
= clichall_pos
[i
+ 1];
10620 *chall_ptr
++ = hex_convert (p1
) << 0
10621 | hex_convert (p0
) << 4;
10628 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10630 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10632 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10634 salt
->salt_len
= salt_len
;
10636 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10637 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10638 digest
[2] = hex_to_uint (&hash_pos
[16]);
10639 digest
[3] = hex_to_uint (&hash_pos
[24]);
10641 digest
[0] = byte_swap_32 (digest
[0]);
10642 digest
[1] = byte_swap_32 (digest
[1]);
10643 digest
[2] = byte_swap_32 (digest
[2]);
10644 digest
[3] = byte_swap_32 (digest
[3]);
10646 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10648 uint digest_tmp
[2];
10650 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10651 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10653 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10654 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10656 /* special case 2: ESS */
10658 if (srvchall_len
== 48)
10660 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10664 w
[ 0] = netntlm
->chall_buf
[6];
10665 w
[ 1] = netntlm
->chall_buf
[7];
10666 w
[ 2] = netntlm
->chall_buf
[0];
10667 w
[ 3] = netntlm
->chall_buf
[1];
10690 salt
->salt_buf
[0] = dgst
[0];
10691 salt
->salt_buf
[1] = dgst
[1];
10695 /* precompute netntlmv1 exploit start */
10697 for (uint i
= 0; i
< 0x10000; i
++)
10699 uint key_md4
[2] = { i
, 0 };
10700 uint key_des
[2] = { 0, 0 };
10702 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10707 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10709 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10711 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10713 if (data3
[0] != digest_tmp
[0]) continue;
10714 if (data3
[1] != digest_tmp
[1]) continue;
10716 salt
->salt_buf
[2] = i
;
10718 salt
->salt_len
= 24;
10723 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10724 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10726 /* precompute netntlmv1 exploit stop */
10730 IP (digest
[0], digest
[1], tt
);
10731 IP (digest
[2], digest
[3], tt
);
10733 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10734 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10735 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10736 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10738 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10740 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10741 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10743 return (PARSER_OK
);
10746 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10748 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10750 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10752 salt_t
*salt
= hash_buf
->salt
;
10754 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10760 char *user_pos
= input_buf
;
10762 char *unused_pos
= strchr (user_pos
, ':');
10764 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10766 uint user_len
= unused_pos
- user_pos
;
10768 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10772 char *domain_pos
= strchr (unused_pos
, ':');
10774 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10776 uint unused_len
= domain_pos
- unused_pos
;
10778 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10782 char *srvchall_pos
= strchr (domain_pos
, ':');
10784 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10786 uint domain_len
= srvchall_pos
- domain_pos
;
10788 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10792 char *hash_pos
= strchr (srvchall_pos
, ':');
10794 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10796 uint srvchall_len
= hash_pos
- srvchall_pos
;
10798 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10802 char *clichall_pos
= strchr (hash_pos
, ':');
10804 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10806 uint hash_len
= clichall_pos
- hash_pos
;
10808 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10812 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10814 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10816 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10819 * store some data for later use
10822 netntlm
->user_len
= user_len
* 2;
10823 netntlm
->domain_len
= domain_len
* 2;
10824 netntlm
->srvchall_len
= srvchall_len
/ 2;
10825 netntlm
->clichall_len
= clichall_len
/ 2;
10827 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10828 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10831 * handle username and domainname
10834 for (uint i
= 0; i
< user_len
; i
++)
10836 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10837 *userdomain_ptr
++ = 0;
10840 for (uint i
= 0; i
< domain_len
; i
++)
10842 *userdomain_ptr
++ = domain_pos
[i
];
10843 *userdomain_ptr
++ = 0;
10846 *userdomain_ptr
++ = 0x80;
10849 * handle server challenge encoding
10852 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10854 const char p0
= srvchall_pos
[i
+ 0];
10855 const char p1
= srvchall_pos
[i
+ 1];
10857 *chall_ptr
++ = hex_convert (p1
) << 0
10858 | hex_convert (p0
) << 4;
10862 * handle client challenge encoding
10865 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10867 const char p0
= clichall_pos
[i
+ 0];
10868 const char p1
= clichall_pos
[i
+ 1];
10870 *chall_ptr
++ = hex_convert (p1
) << 0
10871 | hex_convert (p0
) << 4;
10874 *chall_ptr
++ = 0x80;
10877 * handle hash itself
10880 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10881 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10882 digest
[2] = hex_to_uint (&hash_pos
[16]);
10883 digest
[3] = hex_to_uint (&hash_pos
[24]);
10885 digest
[0] = byte_swap_32 (digest
[0]);
10886 digest
[1] = byte_swap_32 (digest
[1]);
10887 digest
[2] = byte_swap_32 (digest
[2]);
10888 digest
[3] = byte_swap_32 (digest
[3]);
10891 * reuse challange data as salt_buf, its the buffer that is most likely unique
10894 salt
->salt_buf
[0] = 0;
10895 salt
->salt_buf
[1] = 0;
10896 salt
->salt_buf
[2] = 0;
10897 salt
->salt_buf
[3] = 0;
10898 salt
->salt_buf
[4] = 0;
10899 salt
->salt_buf
[5] = 0;
10900 salt
->salt_buf
[6] = 0;
10901 salt
->salt_buf
[7] = 0;
10905 uptr
= (uint
*) netntlm
->userdomain_buf
;
10907 for (uint i
= 0; i
< 16; i
+= 16)
10909 md5_64 (uptr
, salt
->salt_buf
);
10912 uptr
= (uint
*) netntlm
->chall_buf
;
10914 for (uint i
= 0; i
< 256; i
+= 16)
10916 md5_64 (uptr
, salt
->salt_buf
);
10919 salt
->salt_len
= 16;
10921 return (PARSER_OK
);
10924 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10926 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10928 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10932 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10935 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10937 salt_t
*salt
= hash_buf
->salt
;
10939 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10940 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10941 digest
[2] = hex_to_uint (&input_buf
[16]);
10942 digest
[3] = hex_to_uint (&input_buf
[24]);
10944 digest
[0] = byte_swap_32 (digest
[0]);
10945 digest
[1] = byte_swap_32 (digest
[1]);
10946 digest
[2] = byte_swap_32 (digest
[2]);
10947 digest
[3] = byte_swap_32 (digest
[3]);
10949 digest
[0] -= MD5M_A
;
10950 digest
[1] -= MD5M_B
;
10951 digest
[2] -= MD5M_C
;
10952 digest
[3] -= MD5M_D
;
10954 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10956 uint salt_len
= input_len
- 32 - 1;
10958 char *salt_buf
= input_buf
+ 32 + 1;
10960 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10962 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10964 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10966 salt
->salt_len
= salt_len
;
10968 return (PARSER_OK
);
10971 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10973 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10975 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10979 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
10982 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10984 salt_t
*salt
= hash_buf
->salt
;
10986 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10987 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10988 digest
[2] = hex_to_uint (&input_buf
[16]);
10989 digest
[3] = hex_to_uint (&input_buf
[24]);
10991 digest
[0] = byte_swap_32 (digest
[0]);
10992 digest
[1] = byte_swap_32 (digest
[1]);
10993 digest
[2] = byte_swap_32 (digest
[2]);
10994 digest
[3] = byte_swap_32 (digest
[3]);
10996 digest
[0] -= MD5M_A
;
10997 digest
[1] -= MD5M_B
;
10998 digest
[2] -= MD5M_C
;
10999 digest
[3] -= MD5M_D
;
11001 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11003 uint salt_len
= input_len
- 32 - 1;
11005 char *salt_buf
= input_buf
+ 32 + 1;
11007 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11009 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11011 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11013 salt
->salt_len
= salt_len
;
11015 return (PARSER_OK
);
11018 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11020 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11022 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11024 salt_t
*salt
= hash_buf
->salt
;
11026 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11027 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11028 digest
[2] = hex_to_uint (&input_buf
[16]);
11029 digest
[3] = hex_to_uint (&input_buf
[24]);
11031 digest
[0] = byte_swap_32 (digest
[0]);
11032 digest
[1] = byte_swap_32 (digest
[1]);
11033 digest
[2] = byte_swap_32 (digest
[2]);
11034 digest
[3] = byte_swap_32 (digest
[3]);
11036 digest
[0] -= MD5M_A
;
11037 digest
[1] -= MD5M_B
;
11038 digest
[2] -= MD5M_C
;
11039 digest
[3] -= MD5M_D
;
11042 * This is a virtual salt. While the algorithm is basically not salted
11043 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11044 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11047 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11049 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11051 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11053 salt
->salt_len
= salt_len
;
11055 return (PARSER_OK
);
11058 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11060 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11062 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11066 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11069 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11071 salt_t
*salt
= hash_buf
->salt
;
11073 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11074 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11075 digest
[2] = hex_to_uint (&input_buf
[16]);
11076 digest
[3] = hex_to_uint (&input_buf
[24]);
11078 digest
[0] = byte_swap_32 (digest
[0]);
11079 digest
[1] = byte_swap_32 (digest
[1]);
11080 digest
[2] = byte_swap_32 (digest
[2]);
11081 digest
[3] = byte_swap_32 (digest
[3]);
11083 digest
[0] -= MD5M_A
;
11084 digest
[1] -= MD5M_B
;
11085 digest
[2] -= MD5M_C
;
11086 digest
[3] -= MD5M_D
;
11088 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11090 uint salt_len
= input_len
- 32 - 1;
11092 char *salt_buf
= input_buf
+ 32 + 1;
11094 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11096 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11098 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11100 salt
->salt_len
= salt_len
;
11102 return (PARSER_OK
);
11105 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11107 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11109 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11113 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11116 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11118 salt_t
*salt
= hash_buf
->salt
;
11120 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11121 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11122 digest
[2] = hex_to_uint (&input_buf
[16]);
11123 digest
[3] = hex_to_uint (&input_buf
[24]);
11125 digest
[0] = byte_swap_32 (digest
[0]);
11126 digest
[1] = byte_swap_32 (digest
[1]);
11127 digest
[2] = byte_swap_32 (digest
[2]);
11128 digest
[3] = byte_swap_32 (digest
[3]);
11130 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11132 uint salt_len
= input_len
- 32 - 1;
11134 char *salt_buf
= input_buf
+ 32 + 1;
11136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11140 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11142 salt
->salt_len
= salt_len
;
11144 return (PARSER_OK
);
11147 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11149 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11151 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11155 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11158 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11160 salt_t
*salt
= hash_buf
->salt
;
11162 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11163 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11164 digest
[2] = hex_to_uint (&input_buf
[16]);
11165 digest
[3] = hex_to_uint (&input_buf
[24]);
11167 digest
[0] = byte_swap_32 (digest
[0]);
11168 digest
[1] = byte_swap_32 (digest
[1]);
11169 digest
[2] = byte_swap_32 (digest
[2]);
11170 digest
[3] = byte_swap_32 (digest
[3]);
11172 digest
[0] -= MD4M_A
;
11173 digest
[1] -= MD4M_B
;
11174 digest
[2] -= MD4M_C
;
11175 digest
[3] -= MD4M_D
;
11177 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11179 uint salt_len
= input_len
- 32 - 1;
11181 char *salt_buf
= input_buf
+ 32 + 1;
11183 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11185 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11187 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11189 salt
->salt_len
= salt_len
;
11191 return (PARSER_OK
);
11194 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11196 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11198 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11202 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11205 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11207 salt_t
*salt
= hash_buf
->salt
;
11209 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11210 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11211 digest
[2] = hex_to_uint (&input_buf
[16]);
11212 digest
[3] = hex_to_uint (&input_buf
[24]);
11214 digest
[0] = byte_swap_32 (digest
[0]);
11215 digest
[1] = byte_swap_32 (digest
[1]);
11216 digest
[2] = byte_swap_32 (digest
[2]);
11217 digest
[3] = byte_swap_32 (digest
[3]);
11219 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11221 uint salt_len
= input_len
- 32 - 1;
11223 char *salt_buf
= input_buf
+ 32 + 1;
11225 uint salt_pc_block
[16];
11227 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11229 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11231 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11233 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11235 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11237 salt_pc_block
[14] = salt_len
* 8;
11239 uint salt_pc_digest
[4];
11241 salt_pc_digest
[0] = MAGIC_A
;
11242 salt_pc_digest
[1] = MAGIC_B
;
11243 salt_pc_digest
[2] = MAGIC_C
;
11244 salt_pc_digest
[3] = MAGIC_D
;
11246 md5_64 (salt_pc_block
, salt_pc_digest
);
11248 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11249 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11250 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11251 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11255 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11257 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11259 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11260 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11261 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11262 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11264 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11266 return (PARSER_OK
);
11269 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11271 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11273 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11275 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11276 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11277 digest
[2] = hex_to_uint (&input_buf
[16]);
11278 digest
[3] = hex_to_uint (&input_buf
[24]);
11279 digest
[4] = hex_to_uint (&input_buf
[32]);
11281 digest
[0] -= SHA1M_A
;
11282 digest
[1] -= SHA1M_B
;
11283 digest
[2] -= SHA1M_C
;
11284 digest
[3] -= SHA1M_D
;
11285 digest
[4] -= SHA1M_E
;
11287 return (PARSER_OK
);
11290 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11292 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11294 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11296 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11297 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11298 digest
[2] = hex_to_uint (&input_buf
[16]);
11299 digest
[3] = hex_to_uint (&input_buf
[24]);
11300 digest
[4] = hex_to_uint (&input_buf
[32]);
11302 return (PARSER_OK
);
11305 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11307 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11309 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11313 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11316 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11318 salt_t
*salt
= hash_buf
->salt
;
11320 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11321 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11322 digest
[2] = hex_to_uint (&input_buf
[16]);
11323 digest
[3] = hex_to_uint (&input_buf
[24]);
11324 digest
[4] = hex_to_uint (&input_buf
[32]);
11326 digest
[0] -= SHA1M_A
;
11327 digest
[1] -= SHA1M_B
;
11328 digest
[2] -= SHA1M_C
;
11329 digest
[3] -= SHA1M_D
;
11330 digest
[4] -= SHA1M_E
;
11332 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11334 uint salt_len
= input_len
- 40 - 1;
11336 char *salt_buf
= input_buf
+ 40 + 1;
11338 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11340 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11342 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11344 salt
->salt_len
= salt_len
;
11346 return (PARSER_OK
);
11349 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11351 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11353 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11355 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11359 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11361 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11363 memcpy (digest
, tmp_buf
, 20);
11365 digest
[0] = byte_swap_32 (digest
[0]);
11366 digest
[1] = byte_swap_32 (digest
[1]);
11367 digest
[2] = byte_swap_32 (digest
[2]);
11368 digest
[3] = byte_swap_32 (digest
[3]);
11369 digest
[4] = byte_swap_32 (digest
[4]);
11371 digest
[0] -= SHA1M_A
;
11372 digest
[1] -= SHA1M_B
;
11373 digest
[2] -= SHA1M_C
;
11374 digest
[3] -= SHA1M_D
;
11375 digest
[4] -= SHA1M_E
;
11377 return (PARSER_OK
);
11380 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11382 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11384 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11386 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11388 salt_t
*salt
= hash_buf
->salt
;
11392 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11394 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11396 memcpy (digest
, tmp_buf
, 20);
11398 salt
->salt_len
= tmp_len
- 20;
11400 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11402 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11404 char *ptr
= (char *) salt
->salt_buf
;
11406 ptr
[salt
->salt_len
] = 0x80;
11409 digest
[0] = byte_swap_32 (digest
[0]);
11410 digest
[1] = byte_swap_32 (digest
[1]);
11411 digest
[2] = byte_swap_32 (digest
[2]);
11412 digest
[3] = byte_swap_32 (digest
[3]);
11413 digest
[4] = byte_swap_32 (digest
[4]);
11415 digest
[0] -= SHA1M_A
;
11416 digest
[1] -= SHA1M_B
;
11417 digest
[2] -= SHA1M_C
;
11418 digest
[3] -= SHA1M_D
;
11419 digest
[4] -= SHA1M_E
;
11421 return (PARSER_OK
);
11424 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11426 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11428 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11430 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11432 salt_t
*salt
= hash_buf
->salt
;
11434 char *salt_buf
= input_buf
+ 6;
11438 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11440 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11442 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11444 salt
->salt_len
= salt_len
;
11446 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11448 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11449 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11450 digest
[2] = hex_to_uint (&hash_pos
[16]);
11451 digest
[3] = hex_to_uint (&hash_pos
[24]);
11452 digest
[4] = hex_to_uint (&hash_pos
[32]);
11454 digest
[0] -= SHA1M_A
;
11455 digest
[1] -= SHA1M_B
;
11456 digest
[2] -= SHA1M_C
;
11457 digest
[3] -= SHA1M_D
;
11458 digest
[4] -= SHA1M_E
;
11460 return (PARSER_OK
);
11463 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11465 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11467 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11469 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11471 salt_t
*salt
= hash_buf
->salt
;
11473 char *salt_buf
= input_buf
+ 6;
11477 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11479 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11481 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11483 salt
->salt_len
= salt_len
;
11485 char *hash_pos
= input_buf
+ 6 + 8;
11487 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11488 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11489 digest
[2] = hex_to_uint (&hash_pos
[16]);
11490 digest
[3] = hex_to_uint (&hash_pos
[24]);
11491 digest
[4] = hex_to_uint (&hash_pos
[32]);
11493 digest
[0] -= SHA1M_A
;
11494 digest
[1] -= SHA1M_B
;
11495 digest
[2] -= SHA1M_C
;
11496 digest
[3] -= SHA1M_D
;
11497 digest
[4] -= SHA1M_E
;
11499 return (PARSER_OK
);
11502 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11504 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11506 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11508 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11510 salt_t
*salt
= hash_buf
->salt
;
11512 char *salt_buf
= input_buf
+ 6;
11516 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11518 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11520 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11522 salt
->salt_len
= salt_len
;
11524 char *hash_pos
= input_buf
+ 6 + 8;
11526 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11527 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11528 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11529 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11530 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11531 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11532 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11533 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11535 digest
[0] -= SHA512M_A
;
11536 digest
[1] -= SHA512M_B
;
11537 digest
[2] -= SHA512M_C
;
11538 digest
[3] -= SHA512M_D
;
11539 digest
[4] -= SHA512M_E
;
11540 digest
[5] -= SHA512M_F
;
11541 digest
[6] -= SHA512M_G
;
11542 digest
[7] -= SHA512M_H
;
11544 return (PARSER_OK
);
11547 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11549 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11551 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11555 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11558 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11560 salt_t
*salt
= hash_buf
->salt
;
11562 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11563 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11567 digest
[0] = byte_swap_32 (digest
[0]);
11568 digest
[1] = byte_swap_32 (digest
[1]);
11570 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11572 uint salt_len
= input_len
- 16 - 1;
11574 char *salt_buf
= input_buf
+ 16 + 1;
11576 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11578 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11580 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11582 salt
->salt_len
= salt_len
;
11584 return (PARSER_OK
);
11587 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11589 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11591 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11593 salt_t
*salt
= hash_buf
->salt
;
11595 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11596 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11597 digest
[2] = hex_to_uint (&input_buf
[16]);
11598 digest
[3] = hex_to_uint (&input_buf
[24]);
11599 digest
[4] = hex_to_uint (&input_buf
[32]);
11601 digest
[0] -= SHA1M_A
;
11602 digest
[1] -= SHA1M_B
;
11603 digest
[2] -= SHA1M_C
;
11604 digest
[3] -= SHA1M_D
;
11605 digest
[4] -= SHA1M_E
;
11607 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11609 uint salt_len
= input_len
- 40 - 1;
11611 char *salt_buf
= input_buf
+ 40 + 1;
11613 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11615 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11617 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11619 salt
->salt_len
= salt_len
;
11621 return (PARSER_OK
);
11624 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11626 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11628 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11630 salt_t
*salt
= hash_buf
->salt
;
11632 char *hash_pos
= input_buf
;
11634 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11635 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11636 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11637 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11638 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11639 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11640 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11641 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11642 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11643 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11644 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11645 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11646 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11647 digest
[13] = hex_to_uint (&hash_pos
[104]);
11648 digest
[14] = hex_to_uint (&hash_pos
[112]);
11649 digest
[15] = hex_to_uint (&hash_pos
[120]);
11651 char *salt_pos
= input_buf
+ 128;
11653 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11654 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11655 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11656 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11658 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11659 salt
->salt_len
= 16;
11661 return (PARSER_OK
);
11664 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11666 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11668 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
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 return (PARSER_OK
);
11691 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11693 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11695 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11699 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11702 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11704 salt_t
*salt
= hash_buf
->salt
;
11706 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11707 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11708 digest
[2] = hex_to_uint (&input_buf
[16]);
11709 digest
[3] = hex_to_uint (&input_buf
[24]);
11710 digest
[4] = hex_to_uint (&input_buf
[32]);
11711 digest
[5] = hex_to_uint (&input_buf
[40]);
11712 digest
[6] = hex_to_uint (&input_buf
[48]);
11713 digest
[7] = hex_to_uint (&input_buf
[56]);
11715 digest
[0] -= SHA256M_A
;
11716 digest
[1] -= SHA256M_B
;
11717 digest
[2] -= SHA256M_C
;
11718 digest
[3] -= SHA256M_D
;
11719 digest
[4] -= SHA256M_E
;
11720 digest
[5] -= SHA256M_F
;
11721 digest
[6] -= SHA256M_G
;
11722 digest
[7] -= SHA256M_H
;
11724 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11726 uint salt_len
= input_len
- 64 - 1;
11728 char *salt_buf
= input_buf
+ 64 + 1;
11730 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11732 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11734 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11736 salt
->salt_len
= salt_len
;
11738 return (PARSER_OK
);
11741 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11743 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11745 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11747 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11748 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11749 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11750 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11751 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11752 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11756 digest
[0] -= SHA384M_A
;
11757 digest
[1] -= SHA384M_B
;
11758 digest
[2] -= SHA384M_C
;
11759 digest
[3] -= SHA384M_D
;
11760 digest
[4] -= SHA384M_E
;
11761 digest
[5] -= SHA384M_F
;
11765 return (PARSER_OK
);
11768 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11770 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11772 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
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 return (PARSER_OK
);
11795 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11797 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11799 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11803 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11806 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11808 salt_t
*salt
= hash_buf
->salt
;
11810 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11811 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11812 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11813 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11814 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11815 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11816 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11817 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11819 digest
[0] -= SHA512M_A
;
11820 digest
[1] -= SHA512M_B
;
11821 digest
[2] -= SHA512M_C
;
11822 digest
[3] -= SHA512M_D
;
11823 digest
[4] -= SHA512M_E
;
11824 digest
[5] -= SHA512M_F
;
11825 digest
[6] -= SHA512M_G
;
11826 digest
[7] -= SHA512M_H
;
11828 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11830 uint salt_len
= input_len
- 128 - 1;
11832 char *salt_buf
= input_buf
+ 128 + 1;
11834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11836 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11840 salt
->salt_len
= salt_len
;
11842 return (PARSER_OK
);
11845 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11847 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11849 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11851 salt_t
*salt
= hash_buf
->salt
;
11853 char *salt_pos
= input_buf
+ 3;
11855 uint iterations_len
= 0;
11857 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11861 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11863 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11864 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11868 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11872 iterations_len
+= 8;
11876 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11879 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11881 char *hash_pos
= strchr (salt_pos
, '$');
11883 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11885 uint salt_len
= hash_pos
- salt_pos
;
11887 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11889 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11891 salt
->salt_len
= salt_len
;
11895 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11897 return (PARSER_OK
);
11900 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11902 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11904 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11906 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11908 salt_t
*salt
= hash_buf
->salt
;
11910 uint keccak_mdlen
= input_len
/ 2;
11912 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11914 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11916 digest
[i
] = byte_swap_64 (digest
[i
]);
11919 salt
->keccak_mdlen
= keccak_mdlen
;
11921 return (PARSER_OK
);
11924 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11926 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11928 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11930 salt_t
*salt
= hash_buf
->salt
;
11932 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11935 * Parse that strange long line
11942 in_off
[0] = strtok (input_buf
, ":");
11944 in_len
[0] = strlen (in_off
[0]);
11948 for (i
= 1; i
< 9; i
++)
11950 in_off
[i
] = strtok (NULL
, ":");
11952 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11954 in_len
[i
] = strlen (in_off
[i
]);
11959 ptr
= (char *) ikepsk
->msg_buf
;
11961 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11962 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11963 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11964 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11965 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11966 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11970 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11972 ptr
= (char *) ikepsk
->nr_buf
;
11974 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11975 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11979 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
11982 * Store to database
11987 digest
[0] = hex_to_uint (&ptr
[ 0]);
11988 digest
[1] = hex_to_uint (&ptr
[ 8]);
11989 digest
[2] = hex_to_uint (&ptr
[16]);
11990 digest
[3] = hex_to_uint (&ptr
[24]);
11992 digest
[0] = byte_swap_32 (digest
[0]);
11993 digest
[1] = byte_swap_32 (digest
[1]);
11994 digest
[2] = byte_swap_32 (digest
[2]);
11995 digest
[3] = byte_swap_32 (digest
[3]);
11997 salt
->salt_len
= 32;
11999 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12000 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12001 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12002 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12003 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12004 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12005 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12006 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12008 return (PARSER_OK
);
12011 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12013 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12015 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12017 salt_t
*salt
= hash_buf
->salt
;
12019 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12022 * Parse that strange long line
12029 in_off
[0] = strtok (input_buf
, ":");
12031 in_len
[0] = strlen (in_off
[0]);
12035 for (i
= 1; i
< 9; i
++)
12037 in_off
[i
] = strtok (NULL
, ":");
12039 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12041 in_len
[i
] = strlen (in_off
[i
]);
12046 ptr
= (char *) ikepsk
->msg_buf
;
12048 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12049 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12050 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12051 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12052 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12053 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12057 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12059 ptr
= (char *) ikepsk
->nr_buf
;
12061 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12062 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12066 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12069 * Store to database
12074 digest
[0] = hex_to_uint (&ptr
[ 0]);
12075 digest
[1] = hex_to_uint (&ptr
[ 8]);
12076 digest
[2] = hex_to_uint (&ptr
[16]);
12077 digest
[3] = hex_to_uint (&ptr
[24]);
12078 digest
[4] = hex_to_uint (&ptr
[32]);
12080 salt
->salt_len
= 32;
12082 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12083 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12084 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12085 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12086 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12087 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12088 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12089 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12091 return (PARSER_OK
);
12094 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12096 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12098 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12100 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12101 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12102 digest
[2] = hex_to_uint (&input_buf
[16]);
12103 digest
[3] = hex_to_uint (&input_buf
[24]);
12104 digest
[4] = hex_to_uint (&input_buf
[32]);
12106 digest
[0] = byte_swap_32 (digest
[0]);
12107 digest
[1] = byte_swap_32 (digest
[1]);
12108 digest
[2] = byte_swap_32 (digest
[2]);
12109 digest
[3] = byte_swap_32 (digest
[3]);
12110 digest
[4] = byte_swap_32 (digest
[4]);
12112 return (PARSER_OK
);
12115 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12117 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12119 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12121 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12122 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12123 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12124 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12125 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12126 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12127 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12128 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12129 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12130 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12131 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12132 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12133 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12134 digest
[13] = hex_to_uint (&input_buf
[104]);
12135 digest
[14] = hex_to_uint (&input_buf
[112]);
12136 digest
[15] = hex_to_uint (&input_buf
[120]);
12138 return (PARSER_OK
);
12141 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12143 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12145 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12147 salt_t
*salt
= hash_buf
->salt
;
12149 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12150 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12151 digest
[2] = hex_to_uint (&input_buf
[16]);
12152 digest
[3] = hex_to_uint (&input_buf
[24]);
12153 digest
[4] = hex_to_uint (&input_buf
[32]);
12155 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12157 uint salt_len
= input_len
- 40 - 1;
12159 char *salt_buf
= input_buf
+ 40 + 1;
12161 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12163 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12165 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12167 salt
->salt_len
= salt_len
;
12169 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12171 return (PARSER_OK
);
12174 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12176 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12178 salt_t
*salt
= hash_buf
->salt
;
12180 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12182 if (input_len
== 0)
12184 log_error ("TrueCrypt container not specified");
12189 FILE *fp
= fopen (input_buf
, "rb");
12193 log_error ("%s: %s", input_buf
, strerror (errno
));
12200 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12204 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12206 memcpy (tc
->salt_buf
, buf
, 64);
12208 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12210 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12212 salt
->salt_len
= 4;
12214 salt
->salt_iter
= 1000 - 1;
12216 digest
[0] = tc
->data_buf
[0];
12218 return (PARSER_OK
);
12221 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12223 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12225 salt_t
*salt
= hash_buf
->salt
;
12227 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12229 if (input_len
== 0)
12231 log_error ("TrueCrypt container not specified");
12236 FILE *fp
= fopen (input_buf
, "rb");
12240 log_error ("%s: %s", input_buf
, strerror (errno
));
12247 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12251 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12253 memcpy (tc
->salt_buf
, buf
, 64);
12255 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12257 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12259 salt
->salt_len
= 4;
12261 salt
->salt_iter
= 2000 - 1;
12263 digest
[0] = tc
->data_buf
[0];
12265 return (PARSER_OK
);
12268 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12270 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12272 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12274 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12276 salt_t
*salt
= hash_buf
->salt
;
12278 char *salt_pos
= input_buf
+ 6;
12280 char *hash_pos
= strchr (salt_pos
, '$');
12282 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12284 uint salt_len
= hash_pos
- salt_pos
;
12286 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12288 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12290 salt
->salt_len
= salt_len
;
12292 salt
->salt_iter
= 1000;
12296 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12298 return (PARSER_OK
);
12301 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12303 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12305 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12307 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12309 salt_t
*salt
= hash_buf
->salt
;
12311 char *iter_pos
= input_buf
+ 7;
12313 char *salt_pos
= strchr (iter_pos
, '$');
12315 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12319 char *hash_pos
= strchr (salt_pos
, '$');
12321 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12323 uint salt_len
= hash_pos
- salt_pos
;
12325 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12327 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12329 salt
->salt_len
= salt_len
;
12331 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12333 salt
->salt_sign
[0] = atoi (salt_iter
);
12335 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12339 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12341 digest
[0] = byte_swap_32 (digest
[0]);
12342 digest
[1] = byte_swap_32 (digest
[1]);
12343 digest
[2] = byte_swap_32 (digest
[2]);
12344 digest
[3] = byte_swap_32 (digest
[3]);
12345 digest
[4] = byte_swap_32 (digest
[4]);
12347 return (PARSER_OK
);
12350 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12352 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12354 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12356 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12358 salt_t
*salt
= hash_buf
->salt
;
12360 char *iter_pos
= input_buf
+ 9;
12362 char *salt_pos
= strchr (iter_pos
, '$');
12364 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12368 char *hash_pos
= strchr (salt_pos
, '$');
12370 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12372 uint salt_len
= hash_pos
- salt_pos
;
12374 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12376 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12378 salt
->salt_len
= salt_len
;
12380 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12382 salt
->salt_sign
[0] = atoi (salt_iter
);
12384 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12388 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12390 digest
[0] = byte_swap_32 (digest
[0]);
12391 digest
[1] = byte_swap_32 (digest
[1]);
12392 digest
[2] = byte_swap_32 (digest
[2]);
12393 digest
[3] = byte_swap_32 (digest
[3]);
12394 digest
[4] = byte_swap_32 (digest
[4]);
12395 digest
[5] = byte_swap_32 (digest
[5]);
12396 digest
[6] = byte_swap_32 (digest
[6]);
12397 digest
[7] = byte_swap_32 (digest
[7]);
12399 return (PARSER_OK
);
12402 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12404 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12406 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12408 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12410 salt_t
*salt
= hash_buf
->salt
;
12412 char *iter_pos
= input_buf
+ 9;
12414 char *salt_pos
= strchr (iter_pos
, '$');
12416 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12420 char *hash_pos
= strchr (salt_pos
, '$');
12422 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12424 uint salt_len
= hash_pos
- salt_pos
;
12426 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12428 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12430 salt
->salt_len
= salt_len
;
12432 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12434 salt
->salt_sign
[0] = atoi (salt_iter
);
12436 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12440 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12442 digest
[0] = byte_swap_64 (digest
[0]);
12443 digest
[1] = byte_swap_64 (digest
[1]);
12444 digest
[2] = byte_swap_64 (digest
[2]);
12445 digest
[3] = byte_swap_64 (digest
[3]);
12446 digest
[4] = byte_swap_64 (digest
[4]);
12447 digest
[5] = byte_swap_64 (digest
[5]);
12448 digest
[6] = byte_swap_64 (digest
[6]);
12449 digest
[7] = byte_swap_64 (digest
[7]);
12451 return (PARSER_OK
);
12454 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12456 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12458 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12460 salt_t
*salt
= hash_buf
->salt
;
12462 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12468 char *iterations_pos
= input_buf
;
12470 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12472 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12474 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12476 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12480 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12482 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12484 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12486 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12488 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12490 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12495 * pbkdf2 iterations
12498 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12501 * handle salt encoding
12504 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12506 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12508 const char p0
= saltbuf_pos
[i
+ 0];
12509 const char p1
= saltbuf_pos
[i
+ 1];
12511 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12512 | hex_convert (p0
) << 4;
12515 salt
->salt_len
= saltbuf_len
/ 2;
12518 * handle cipher encoding
12521 uint
*tmp
= (uint
*) mymalloc (32);
12523 char *cipherbuf_ptr
= (char *) tmp
;
12525 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12527 const char p0
= cipherbuf_pos
[i
+ 0];
12528 const char p1
= cipherbuf_pos
[i
+ 1];
12530 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12531 | hex_convert (p0
) << 4;
12534 // iv is stored at salt_buf 4 (length 16)
12535 // data is stored at salt_buf 8 (length 16)
12537 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12538 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12539 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12540 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12542 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12543 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12544 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12545 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12549 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12551 const char p0
= cipherbuf_pos
[j
+ 0];
12552 const char p1
= cipherbuf_pos
[j
+ 1];
12554 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12555 | hex_convert (p0
) << 4;
12562 digest
[0] = 0x10101010;
12563 digest
[1] = 0x10101010;
12564 digest
[2] = 0x10101010;
12565 digest
[3] = 0x10101010;
12567 return (PARSER_OK
);
12570 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12572 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12574 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12576 salt_t
*salt
= hash_buf
->salt
;
12578 char *hashbuf_pos
= input_buf
;
12580 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12582 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12584 uint hash_len
= iterations_pos
- hashbuf_pos
;
12586 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12590 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12592 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12594 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12598 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12600 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12602 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12604 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12606 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12608 salt
->salt_len
= salt_len
;
12610 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12612 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12613 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12614 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12615 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12617 return (PARSER_OK
);
12620 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12622 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12624 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12626 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12627 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12628 digest
[2] = hex_to_uint (&input_buf
[16]);
12629 digest
[3] = hex_to_uint (&input_buf
[24]);
12630 digest
[4] = hex_to_uint (&input_buf
[32]);
12631 digest
[5] = hex_to_uint (&input_buf
[40]);
12632 digest
[6] = hex_to_uint (&input_buf
[48]);
12633 digest
[7] = hex_to_uint (&input_buf
[56]);
12635 digest
[0] = byte_swap_32 (digest
[0]);
12636 digest
[1] = byte_swap_32 (digest
[1]);
12637 digest
[2] = byte_swap_32 (digest
[2]);
12638 digest
[3] = byte_swap_32 (digest
[3]);
12639 digest
[4] = byte_swap_32 (digest
[4]);
12640 digest
[5] = byte_swap_32 (digest
[5]);
12641 digest
[6] = byte_swap_32 (digest
[6]);
12642 digest
[7] = byte_swap_32 (digest
[7]);
12644 return (PARSER_OK
);
12647 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12649 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12651 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12653 salt_t
*salt
= hash_buf
->salt
;
12655 char *salt_pos
= input_buf
+ 3;
12657 uint iterations_len
= 0;
12659 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12663 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12665 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12666 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12670 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12674 iterations_len
+= 8;
12678 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12681 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12683 char *hash_pos
= strchr (salt_pos
, '$');
12685 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12687 uint salt_len
= hash_pos
- salt_pos
;
12689 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12691 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12693 salt
->salt_len
= salt_len
;
12697 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12699 return (PARSER_OK
);
12702 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12704 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12706 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12708 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12710 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12712 salt_t
*salt
= hash_buf
->salt
;
12714 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12716 char *iter_pos
= input_buf
+ 4;
12718 char *salt_pos
= strchr (iter_pos
, '$');
12720 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12724 char *hash_pos
= strchr (salt_pos
, '$');
12726 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12728 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12732 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12733 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12734 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12735 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12736 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12737 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12738 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12739 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12741 uint salt_len
= hash_pos
- salt_pos
- 1;
12743 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12745 salt
->salt_len
= salt_len
/ 2;
12747 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12748 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12749 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12750 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12751 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12752 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12753 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12754 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12756 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12757 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12758 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12759 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12760 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12761 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12762 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12763 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12764 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12765 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12767 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12769 salt
->salt_iter
= atoi (iter_pos
) - 1;
12771 return (PARSER_OK
);
12774 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12776 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12778 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12780 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12782 salt_t
*salt
= hash_buf
->salt
;
12784 char *salt_pos
= input_buf
+ 14;
12786 char *hash_pos
= strchr (salt_pos
, '*');
12788 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12792 uint salt_len
= hash_pos
- salt_pos
- 1;
12794 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12796 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12798 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12800 salt
->salt_len
= salt_len
;
12802 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12804 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12806 memcpy (digest
, tmp_buf
, 32);
12808 digest
[0] = byte_swap_32 (digest
[0]);
12809 digest
[1] = byte_swap_32 (digest
[1]);
12810 digest
[2] = byte_swap_32 (digest
[2]);
12811 digest
[3] = byte_swap_32 (digest
[3]);
12812 digest
[4] = byte_swap_32 (digest
[4]);
12813 digest
[5] = byte_swap_32 (digest
[5]);
12814 digest
[6] = byte_swap_32 (digest
[6]);
12815 digest
[7] = byte_swap_32 (digest
[7]);
12817 digest
[0] -= SHA256M_A
;
12818 digest
[1] -= SHA256M_B
;
12819 digest
[2] -= SHA256M_C
;
12820 digest
[3] -= SHA256M_D
;
12821 digest
[4] -= SHA256M_E
;
12822 digest
[5] -= SHA256M_F
;
12823 digest
[6] -= SHA256M_G
;
12824 digest
[7] -= SHA256M_H
;
12826 return (PARSER_OK
);
12829 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12831 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12833 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12835 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12837 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12839 salt_t
*salt
= hash_buf
->salt
;
12841 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12843 char *iter_pos
= input_buf
+ 19;
12845 char *salt_pos
= strchr (iter_pos
, '.');
12847 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12851 char *hash_pos
= strchr (salt_pos
, '.');
12853 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12855 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12859 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12860 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12861 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12862 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12863 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12864 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12865 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12866 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12868 uint salt_len
= hash_pos
- salt_pos
- 1;
12872 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12876 for (i
= 0; i
< salt_len
; i
++)
12878 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12881 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12882 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12884 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12886 salt
->salt_len
= salt_len
;
12888 salt
->salt_iter
= atoi (iter_pos
) - 1;
12890 return (PARSER_OK
);
12893 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12895 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12897 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12899 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12901 salt_t
*salt
= hash_buf
->salt
;
12905 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12907 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12909 memcpy (digest
, tmp_buf
, 64);
12911 digest
[0] = byte_swap_64 (digest
[0]);
12912 digest
[1] = byte_swap_64 (digest
[1]);
12913 digest
[2] = byte_swap_64 (digest
[2]);
12914 digest
[3] = byte_swap_64 (digest
[3]);
12915 digest
[4] = byte_swap_64 (digest
[4]);
12916 digest
[5] = byte_swap_64 (digest
[5]);
12917 digest
[6] = byte_swap_64 (digest
[6]);
12918 digest
[7] = byte_swap_64 (digest
[7]);
12920 digest
[0] -= SHA512M_A
;
12921 digest
[1] -= SHA512M_B
;
12922 digest
[2] -= SHA512M_C
;
12923 digest
[3] -= SHA512M_D
;
12924 digest
[4] -= SHA512M_E
;
12925 digest
[5] -= SHA512M_F
;
12926 digest
[6] -= SHA512M_G
;
12927 digest
[7] -= SHA512M_H
;
12929 salt
->salt_len
= tmp_len
- 64;
12931 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12933 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12935 char *ptr
= (char *) salt
->salt_buf
;
12937 ptr
[salt
->salt_len
] = 0x80;
12940 return (PARSER_OK
);
12943 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12945 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12947 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12951 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12954 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12956 salt_t
*salt
= hash_buf
->salt
;
12958 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12959 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12960 digest
[2] = hex_to_uint (&input_buf
[16]);
12961 digest
[3] = hex_to_uint (&input_buf
[24]);
12963 digest
[0] = byte_swap_32 (digest
[0]);
12964 digest
[1] = byte_swap_32 (digest
[1]);
12965 digest
[2] = byte_swap_32 (digest
[2]);
12966 digest
[3] = byte_swap_32 (digest
[3]);
12968 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12970 uint salt_len
= input_len
- 32 - 1;
12972 char *salt_buf
= input_buf
+ 32 + 1;
12974 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12976 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12978 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12980 salt
->salt_len
= salt_len
;
12982 return (PARSER_OK
);
12985 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12987 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12989 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
12993 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
12996 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12998 salt_t
*salt
= hash_buf
->salt
;
13000 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13001 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13002 digest
[2] = hex_to_uint (&input_buf
[16]);
13003 digest
[3] = hex_to_uint (&input_buf
[24]);
13004 digest
[4] = hex_to_uint (&input_buf
[32]);
13006 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13008 uint salt_len
= input_len
- 40 - 1;
13010 char *salt_buf
= input_buf
+ 40 + 1;
13012 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13014 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13016 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13018 salt
->salt_len
= salt_len
;
13020 return (PARSER_OK
);
13023 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13025 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13027 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13031 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13034 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13036 salt_t
*salt
= hash_buf
->salt
;
13038 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13039 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13040 digest
[2] = hex_to_uint (&input_buf
[16]);
13041 digest
[3] = hex_to_uint (&input_buf
[24]);
13042 digest
[4] = hex_to_uint (&input_buf
[32]);
13043 digest
[5] = hex_to_uint (&input_buf
[40]);
13044 digest
[6] = hex_to_uint (&input_buf
[48]);
13045 digest
[7] = hex_to_uint (&input_buf
[56]);
13047 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13049 uint salt_len
= input_len
- 64 - 1;
13051 char *salt_buf
= input_buf
+ 64 + 1;
13053 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13055 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13057 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13059 salt
->salt_len
= salt_len
;
13061 return (PARSER_OK
);
13064 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13066 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13068 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13072 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13075 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13077 salt_t
*salt
= hash_buf
->salt
;
13079 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13080 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13081 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13082 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13083 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13084 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13085 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13086 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13088 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13090 uint salt_len
= input_len
- 128 - 1;
13092 char *salt_buf
= input_buf
+ 128 + 1;
13094 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13096 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13098 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13100 salt
->salt_len
= salt_len
;
13102 return (PARSER_OK
);
13105 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13107 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13109 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13111 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13113 salt_t
*salt
= hash_buf
->salt
;
13115 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13121 char *user_pos
= input_buf
+ 10 + 1;
13123 char *realm_pos
= strchr (user_pos
, '$');
13125 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13127 uint user_len
= realm_pos
- user_pos
;
13129 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13133 char *salt_pos
= strchr (realm_pos
, '$');
13135 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13137 uint realm_len
= salt_pos
- realm_pos
;
13139 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13143 char *data_pos
= strchr (salt_pos
, '$');
13145 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13147 uint salt_len
= data_pos
- salt_pos
;
13149 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13153 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13155 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13161 memcpy (krb5pa
->user
, user_pos
, user_len
);
13162 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13163 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13165 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13167 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13169 const char p0
= data_pos
[i
+ 0];
13170 const char p1
= data_pos
[i
+ 1];
13172 *timestamp_ptr
++ = hex_convert (p1
) << 0
13173 | hex_convert (p0
) << 4;
13176 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13178 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13180 const char p0
= data_pos
[i
+ 0];
13181 const char p1
= data_pos
[i
+ 1];
13183 *checksum_ptr
++ = hex_convert (p1
) << 0
13184 | hex_convert (p0
) << 4;
13188 * copy some data to generic buffers to make sorting happy
13191 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13192 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13193 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13194 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13195 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13196 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13197 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13198 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13199 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13201 salt
->salt_len
= 36;
13203 digest
[0] = krb5pa
->checksum
[0];
13204 digest
[1] = krb5pa
->checksum
[1];
13205 digest
[2] = krb5pa
->checksum
[2];
13206 digest
[3] = krb5pa
->checksum
[3];
13208 return (PARSER_OK
);
13211 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13213 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13215 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13217 salt_t
*salt
= hash_buf
->salt
;
13223 char *salt_pos
= input_buf
;
13225 char *hash_pos
= strchr (salt_pos
, '$');
13227 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13229 uint salt_len
= hash_pos
- salt_pos
;
13231 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13235 uint hash_len
= input_len
- 1 - salt_len
;
13237 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13245 for (uint i
= 0; i
< salt_len
; i
++)
13247 if (salt_pos
[i
] == ' ') continue;
13252 // SAP user names cannot be longer than 12 characters
13253 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13255 // SAP user name cannot start with ! or ?
13256 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13262 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13264 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13266 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13268 salt
->salt_len
= salt_len
;
13270 digest
[0] = hex_to_uint (&hash_pos
[0]);
13271 digest
[1] = hex_to_uint (&hash_pos
[8]);
13275 digest
[0] = byte_swap_32 (digest
[0]);
13276 digest
[1] = byte_swap_32 (digest
[1]);
13278 return (PARSER_OK
);
13281 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13283 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13285 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13287 salt_t
*salt
= hash_buf
->salt
;
13293 char *salt_pos
= input_buf
;
13295 char *hash_pos
= strchr (salt_pos
, '$');
13297 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13299 uint salt_len
= hash_pos
- salt_pos
;
13301 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13305 uint hash_len
= input_len
- 1 - salt_len
;
13307 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13315 for (uint i
= 0; i
< salt_len
; i
++)
13317 if (salt_pos
[i
] == ' ') continue;
13322 // SAP user names cannot be longer than 12 characters
13323 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13325 // SAP user name cannot start with ! or ?
13326 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13332 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13334 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13336 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13338 salt
->salt_len
= salt_len
;
13340 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13341 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13342 digest
[2] = hex_to_uint (&hash_pos
[16]);
13343 digest
[3] = hex_to_uint (&hash_pos
[24]);
13344 digest
[4] = hex_to_uint (&hash_pos
[32]);
13346 return (PARSER_OK
);
13349 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13351 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13353 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13355 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13357 salt_t
*salt
= hash_buf
->salt
;
13359 char *iter_pos
= input_buf
+ 3;
13361 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13363 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13365 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13367 salt
->salt_iter
= salt_iter
;
13369 char *salt_pos
= iter_pos
+ 1;
13373 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13375 salt
->salt_len
= salt_len
;
13377 char *hash_pos
= salt_pos
+ salt_len
;
13379 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13383 char *tmp
= (char *) salt
->salt_buf_pc
;
13385 tmp
[0] = hash_pos
[42];
13389 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13390 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13391 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13392 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13398 return (PARSER_OK
);
13401 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13403 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13405 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13407 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13409 salt_t
*salt
= hash_buf
->salt
;
13411 char *salt_buf
= input_buf
+ 6;
13413 uint salt_len
= 16;
13415 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13417 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13419 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13421 salt
->salt_len
= salt_len
;
13423 char *hash_pos
= input_buf
+ 6 + 16;
13425 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13426 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13427 digest
[2] = hex_to_uint (&hash_pos
[16]);
13428 digest
[3] = hex_to_uint (&hash_pos
[24]);
13429 digest
[4] = hex_to_uint (&hash_pos
[32]);
13430 digest
[5] = hex_to_uint (&hash_pos
[40]);
13431 digest
[6] = hex_to_uint (&hash_pos
[48]);
13432 digest
[7] = hex_to_uint (&hash_pos
[56]);
13434 return (PARSER_OK
);
13437 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13439 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13441 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13443 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13444 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13448 return (PARSER_OK
);
13451 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13453 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13455 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13457 salt_t
*salt
= hash_buf
->salt
;
13459 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13461 char *saltbuf_pos
= input_buf
;
13463 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13465 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13467 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13469 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13470 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13472 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13476 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13478 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13480 char *salt_ptr
= (char *) saltbuf_pos
;
13481 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13486 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13488 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13491 rakp_ptr
[j
] = 0x80;
13493 rakp
->salt_len
= j
;
13495 for (i
= 0; i
< 64; i
++)
13497 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13500 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13501 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13502 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13503 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13504 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13505 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13506 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13507 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13509 salt
->salt_len
= 32; // muss min. 32 haben
13511 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13512 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13513 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13514 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13515 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13517 return (PARSER_OK
);
13520 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13522 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13524 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13526 salt_t
*salt
= hash_buf
->salt
;
13528 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13530 char *salt_pos
= input_buf
+ 1;
13532 memcpy (salt
->salt_buf
, salt_pos
, 8);
13534 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13535 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13537 salt
->salt_len
= 8;
13539 char *hash_pos
= salt_pos
+ 8;
13541 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13542 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13543 digest
[2] = hex_to_uint (&hash_pos
[16]);
13544 digest
[3] = hex_to_uint (&hash_pos
[24]);
13545 digest
[4] = hex_to_uint (&hash_pos
[32]);
13547 digest
[0] -= SHA1M_A
;
13548 digest
[1] -= SHA1M_B
;
13549 digest
[2] -= SHA1M_C
;
13550 digest
[3] -= SHA1M_D
;
13551 digest
[4] -= SHA1M_E
;
13553 return (PARSER_OK
);
13556 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13558 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13560 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13562 salt_t
*salt
= hash_buf
->salt
;
13564 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13565 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13566 digest
[2] = hex_to_uint (&input_buf
[16]);
13567 digest
[3] = hex_to_uint (&input_buf
[24]);
13569 digest
[0] = byte_swap_32 (digest
[0]);
13570 digest
[1] = byte_swap_32 (digest
[1]);
13571 digest
[2] = byte_swap_32 (digest
[2]);
13572 digest
[3] = byte_swap_32 (digest
[3]);
13574 digest
[0] -= MD5M_A
;
13575 digest
[1] -= MD5M_B
;
13576 digest
[2] -= MD5M_C
;
13577 digest
[3] -= MD5M_D
;
13579 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13581 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13583 uint32_t *salt_buf
= salt
->salt_buf
;
13585 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13586 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13587 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13588 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13590 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13591 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13592 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13593 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13595 salt
->salt_len
= 16 + 1;
13597 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13599 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13601 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13603 return (PARSER_OK
);
13606 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13608 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13610 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13612 salt_t
*salt
= hash_buf
->salt
;
13614 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13620 char *hashbuf_pos
= input_buf
;
13622 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13624 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13626 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13628 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13632 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13634 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13636 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13638 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13642 char *databuf_pos
= strchr (iteration_pos
, ':');
13644 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13646 const uint iteration_len
= databuf_pos
- iteration_pos
;
13648 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13649 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13651 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13653 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13654 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13660 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13661 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13662 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13663 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13664 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13665 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13666 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13667 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13671 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13673 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13675 const char p0
= saltbuf_pos
[i
+ 0];
13676 const char p1
= saltbuf_pos
[i
+ 1];
13678 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13679 | hex_convert (p0
) << 4;
13682 salt
->salt_buf
[4] = 0x01000000;
13683 salt
->salt_buf
[5] = 0x80;
13685 salt
->salt_len
= saltbuf_len
/ 2;
13689 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13693 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13695 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13697 const char p0
= databuf_pos
[i
+ 0];
13698 const char p1
= databuf_pos
[i
+ 1];
13700 *databuf_ptr
++ = hex_convert (p1
) << 0
13701 | hex_convert (p0
) << 4;
13704 *databuf_ptr
++ = 0x80;
13706 for (uint i
= 0; i
< 512; i
++)
13708 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13711 cloudkey
->data_len
= databuf_len
/ 2;
13713 return (PARSER_OK
);
13716 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13718 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13720 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13722 salt_t
*salt
= hash_buf
->salt
;
13728 char *hashbuf_pos
= input_buf
;
13730 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13732 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13734 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13736 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13740 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13742 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13744 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13746 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13748 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13752 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13754 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13756 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13758 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13760 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13764 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13766 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13767 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13769 // ok, the plan for this algorithm is the following:
13770 // we have 2 salts here, the domain-name and a random salt
13771 // while both are used in the initial transformation,
13772 // only the random salt is used in the following iterations
13773 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13774 // and one that includes only the real salt (stored into salt_buf[]).
13775 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13777 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13779 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13781 memcpy (digest
, tmp_buf
, 20);
13783 digest
[0] = byte_swap_32 (digest
[0]);
13784 digest
[1] = byte_swap_32 (digest
[1]);
13785 digest
[2] = byte_swap_32 (digest
[2]);
13786 digest
[3] = byte_swap_32 (digest
[3]);
13787 digest
[4] = byte_swap_32 (digest
[4]);
13791 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13793 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13795 char *len_ptr
= NULL
;
13797 for (uint i
= 0; i
< domainbuf_len
; i
++)
13799 if (salt_buf_pc_ptr
[i
] == '.')
13801 len_ptr
= &salt_buf_pc_ptr
[i
];
13811 salt
->salt_buf_pc
[7] = domainbuf_len
;
13815 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13817 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13819 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13821 salt
->salt_len
= salt_len
;
13825 salt
->salt_iter
= atoi (iteration_pos
);
13827 return (PARSER_OK
);
13830 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13832 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13834 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13836 salt_t
*salt
= hash_buf
->salt
;
13838 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13839 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13840 digest
[2] = hex_to_uint (&input_buf
[16]);
13841 digest
[3] = hex_to_uint (&input_buf
[24]);
13842 digest
[4] = hex_to_uint (&input_buf
[32]);
13844 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13846 uint salt_len
= input_len
- 40 - 1;
13848 char *salt_buf
= input_buf
+ 40 + 1;
13850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13852 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13854 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13856 salt
->salt_len
= salt_len
;
13858 return (PARSER_OK
);
13861 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13863 const uint8_t ascii_to_ebcdic
[] =
13865 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13866 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13867 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13868 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13869 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13870 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13871 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13872 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13873 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13874 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13875 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13876 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13877 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13878 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13879 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13880 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13883 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13885 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13887 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13889 salt_t
*salt
= hash_buf
->salt
;
13891 char *salt_pos
= input_buf
+ 6 + 1;
13893 char *digest_pos
= strchr (salt_pos
, '*');
13895 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13897 uint salt_len
= digest_pos
- salt_pos
;
13899 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13901 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13903 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13907 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13908 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13910 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13912 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13914 salt
->salt_len
= salt_len
;
13916 for (uint i
= 0; i
< salt_len
; i
++)
13918 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13920 for (uint i
= salt_len
; i
< 8; i
++)
13922 salt_buf_pc_ptr
[i
] = 0x40;
13927 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13929 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13930 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13932 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13933 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13935 digest
[0] = byte_swap_32 (digest
[0]);
13936 digest
[1] = byte_swap_32 (digest
[1]);
13938 IP (digest
[0], digest
[1], tt
);
13940 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13941 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13945 return (PARSER_OK
);
13948 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13950 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13952 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13954 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13955 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13956 digest
[2] = hex_to_uint (&input_buf
[16]);
13957 digest
[3] = hex_to_uint (&input_buf
[24]);
13959 digest
[0] = byte_swap_32 (digest
[0]);
13960 digest
[1] = byte_swap_32 (digest
[1]);
13961 digest
[2] = byte_swap_32 (digest
[2]);
13962 digest
[3] = byte_swap_32 (digest
[3]);
13964 return (PARSER_OK
);
13967 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13969 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13971 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13973 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13975 salt_t
*salt
= hash_buf
->salt
;
13979 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13981 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
13983 tmp_buf
[3] += -4; // dont ask!
13985 memcpy (salt
->salt_buf
, tmp_buf
, 5);
13987 salt
->salt_len
= 5;
13989 memcpy (digest
, tmp_buf
+ 5, 9);
13991 // yes, only 9 byte are needed to crack, but 10 to display
13993 salt
->salt_buf_pc
[7] = input_buf
[20];
13995 return (PARSER_OK
);
13998 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14000 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14002 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14004 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14006 salt_t
*salt
= hash_buf
->salt
;
14010 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14012 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14014 tmp_buf
[3] += -4; // dont ask!
14018 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14020 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)
14024 char tmp_iter_buf
[11];
14026 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14028 tmp_iter_buf
[10] = 0;
14030 salt
->salt_iter
= atoi (tmp_iter_buf
);
14032 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14034 return (PARSER_SALT_ITERATION
);
14037 salt
->salt_iter
--; // first round in init
14039 // 2 additional bytes for display only
14041 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14042 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14046 memcpy (digest
, tmp_buf
+ 28, 8);
14048 digest
[0] = byte_swap_32 (digest
[0]);
14049 digest
[1] = byte_swap_32 (digest
[1]);
14053 return (PARSER_OK
);
14056 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14058 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14060 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14062 salt_t
*salt
= hash_buf
->salt
;
14064 char *salt_buf_pos
= input_buf
;
14066 char *hash_buf_pos
= salt_buf_pos
+ 6;
14068 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14069 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14070 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14071 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14072 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14073 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14074 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14075 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14077 digest
[0] -= SHA256M_A
;
14078 digest
[1] -= SHA256M_B
;
14079 digest
[2] -= SHA256M_C
;
14080 digest
[3] -= SHA256M_D
;
14081 digest
[4] -= SHA256M_E
;
14082 digest
[5] -= SHA256M_F
;
14083 digest
[6] -= SHA256M_G
;
14084 digest
[7] -= SHA256M_H
;
14086 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14088 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14090 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14092 salt
->salt_len
= salt_len
;
14094 return (PARSER_OK
);
14097 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14099 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14101 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14103 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14105 salt_t
*salt
= hash_buf
->salt
;
14107 char *salt_buf
= input_buf
+ 6;
14109 char *digest_buf
= strchr (salt_buf
, '$');
14111 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14113 uint salt_len
= digest_buf
- salt_buf
;
14115 digest_buf
++; // skip the '$' symbol
14117 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14119 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14121 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14123 salt
->salt_len
= salt_len
;
14125 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14126 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14127 digest
[2] = hex_to_uint (&digest_buf
[16]);
14128 digest
[3] = hex_to_uint (&digest_buf
[24]);
14130 digest
[0] = byte_swap_32 (digest
[0]);
14131 digest
[1] = byte_swap_32 (digest
[1]);
14132 digest
[2] = byte_swap_32 (digest
[2]);
14133 digest
[3] = byte_swap_32 (digest
[3]);
14135 digest
[0] -= MD5M_A
;
14136 digest
[1] -= MD5M_B
;
14137 digest
[2] -= MD5M_C
;
14138 digest
[3] -= MD5M_D
;
14140 return (PARSER_OK
);
14143 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14145 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14147 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14149 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14151 salt_t
*salt
= hash_buf
->salt
;
14153 char *salt_buf
= input_buf
+ 3;
14155 char *digest_buf
= strchr (salt_buf
, '$');
14157 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14159 uint salt_len
= digest_buf
- salt_buf
;
14161 digest_buf
++; // skip the '$' symbol
14163 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14165 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14167 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14169 salt_buf_ptr
[salt_len
] = 0x2d;
14171 salt
->salt_len
= salt_len
+ 1;
14173 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14174 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14175 digest
[2] = hex_to_uint (&digest_buf
[16]);
14176 digest
[3] = hex_to_uint (&digest_buf
[24]);
14178 digest
[0] = byte_swap_32 (digest
[0]);
14179 digest
[1] = byte_swap_32 (digest
[1]);
14180 digest
[2] = byte_swap_32 (digest
[2]);
14181 digest
[3] = byte_swap_32 (digest
[3]);
14183 digest
[0] -= MD5M_A
;
14184 digest
[1] -= MD5M_B
;
14185 digest
[2] -= MD5M_C
;
14186 digest
[3] -= MD5M_D
;
14188 return (PARSER_OK
);
14191 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14193 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14195 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14199 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14201 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14203 memcpy (digest
, tmp_buf
, 20);
14205 digest
[0] = byte_swap_32 (digest
[0]);
14206 digest
[1] = byte_swap_32 (digest
[1]);
14207 digest
[2] = byte_swap_32 (digest
[2]);
14208 digest
[3] = byte_swap_32 (digest
[3]);
14209 digest
[4] = byte_swap_32 (digest
[4]);
14211 digest
[0] -= SHA1M_A
;
14212 digest
[1] -= SHA1M_B
;
14213 digest
[2] -= SHA1M_C
;
14214 digest
[3] -= SHA1M_D
;
14215 digest
[4] -= SHA1M_E
;
14217 return (PARSER_OK
);
14220 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14222 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14224 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14226 salt_t
*salt
= hash_buf
->salt
;
14228 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14229 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14230 digest
[2] = hex_to_uint (&input_buf
[16]);
14231 digest
[3] = hex_to_uint (&input_buf
[24]);
14233 digest
[0] = byte_swap_32 (digest
[0]);
14234 digest
[1] = byte_swap_32 (digest
[1]);
14235 digest
[2] = byte_swap_32 (digest
[2]);
14236 digest
[3] = byte_swap_32 (digest
[3]);
14238 digest
[0] -= MD5M_A
;
14239 digest
[1] -= MD5M_B
;
14240 digest
[2] -= MD5M_C
;
14241 digest
[3] -= MD5M_D
;
14243 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14245 uint salt_len
= input_len
- 32 - 1;
14247 char *salt_buf
= input_buf
+ 32 + 1;
14249 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14251 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14253 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14256 * add static "salt" part
14259 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14263 salt
->salt_len
= salt_len
;
14265 return (PARSER_OK
);
14268 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14270 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14272 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14274 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14276 salt_t
*salt
= hash_buf
->salt
;
14278 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14284 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14286 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14288 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14290 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14292 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14296 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14298 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14300 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14302 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14306 char *keybuf_pos
= strchr (keylen_pos
, '$');
14308 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14310 uint keylen_len
= keybuf_pos
- keylen_pos
;
14312 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14316 char *databuf_pos
= strchr (keybuf_pos
, '$');
14318 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14320 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14322 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14326 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14328 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14334 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14335 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14336 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14337 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14339 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14340 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14341 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14342 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14344 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14345 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14346 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14347 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14349 salt
->salt_len
= 16;
14350 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14352 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14354 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14357 return (PARSER_OK
);
14360 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14362 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14364 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14366 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14368 salt_t
*salt
= hash_buf
->salt
;
14374 // first is the N salt parameter
14376 char *N_pos
= input_buf
+ 6;
14378 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14382 salt
->scrypt_N
= atoi (N_pos
);
14386 char *r_pos
= strchr (N_pos
, ':');
14388 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14392 salt
->scrypt_r
= atoi (r_pos
);
14396 char *p_pos
= strchr (r_pos
, ':');
14398 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14402 salt
->scrypt_p
= atoi (p_pos
);
14406 char *saltbuf_pos
= strchr (p_pos
, ':');
14408 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14412 char *hash_pos
= strchr (saltbuf_pos
, ':');
14414 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14422 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14424 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14426 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14428 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14430 salt
->salt_len
= tmp_len
;
14431 salt
->salt_iter
= 1;
14433 // digest - base64 decode
14435 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14437 tmp_len
= input_len
- (hash_pos
- input_buf
);
14439 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14441 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14443 memcpy (digest
, tmp_buf
, 32);
14445 return (PARSER_OK
);
14448 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14450 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14452 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14454 salt_t
*salt
= hash_buf
->salt
;
14460 char decrypted
[76]; // iv + hash
14462 juniper_decrypt_hash (input_buf
, decrypted
);
14464 char *md5crypt_hash
= decrypted
+ 12;
14466 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14468 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14470 char *salt_pos
= md5crypt_hash
+ 3;
14472 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14474 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14476 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14480 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14482 return (PARSER_OK
);
14485 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14487 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14489 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14491 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14493 salt_t
*salt
= hash_buf
->salt
;
14495 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14501 // first is *raw* salt
14503 char *salt_pos
= input_buf
+ 3;
14505 char *hash_pos
= strchr (salt_pos
, '$');
14507 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14509 uint salt_len
= hash_pos
- salt_pos
;
14511 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14515 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14517 memcpy (salt_buf_ptr
, salt_pos
, 14);
14519 salt_buf_ptr
[17] = 0x01;
14520 salt_buf_ptr
[18] = 0x80;
14522 // add some stuff to normal salt to make sorted happy
14524 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14525 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14526 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14527 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14529 salt
->salt_len
= salt_len
;
14530 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14532 // base64 decode hash
14536 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14538 uint hash_len
= input_len
- 3 - salt_len
- 1;
14540 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14542 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14544 memcpy (digest
, tmp_buf
, 32);
14546 digest
[0] = byte_swap_32 (digest
[0]);
14547 digest
[1] = byte_swap_32 (digest
[1]);
14548 digest
[2] = byte_swap_32 (digest
[2]);
14549 digest
[3] = byte_swap_32 (digest
[3]);
14550 digest
[4] = byte_swap_32 (digest
[4]);
14551 digest
[5] = byte_swap_32 (digest
[5]);
14552 digest
[6] = byte_swap_32 (digest
[6]);
14553 digest
[7] = byte_swap_32 (digest
[7]);
14555 return (PARSER_OK
);
14558 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14560 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14562 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14564 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14566 salt_t
*salt
= hash_buf
->salt
;
14572 // first is *raw* salt
14574 char *salt_pos
= input_buf
+ 3;
14576 char *hash_pos
= strchr (salt_pos
, '$');
14578 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14580 uint salt_len
= hash_pos
- salt_pos
;
14582 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14584 salt
->salt_len
= salt_len
;
14587 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14589 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14590 salt_buf_ptr
[salt_len
] = 0;
14592 // base64 decode hash
14596 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14598 uint hash_len
= input_len
- 3 - salt_len
- 1;
14600 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14602 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14604 memcpy (digest
, tmp_buf
, 32);
14607 salt
->scrypt_N
= 16384;
14608 salt
->scrypt_r
= 1;
14609 salt
->scrypt_p
= 1;
14610 salt
->salt_iter
= 1;
14612 return (PARSER_OK
);
14615 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14617 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14619 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14621 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14623 salt_t
*salt
= hash_buf
->salt
;
14625 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14631 char *version_pos
= input_buf
+ 8 + 1;
14633 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14635 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14637 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14639 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14641 verifierHashSize_pos
++;
14643 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14645 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14647 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14649 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14653 char *saltSize_pos
= strchr (keySize_pos
, '*');
14655 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14657 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14659 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14663 char *osalt_pos
= strchr (saltSize_pos
, '*');
14665 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14667 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14669 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14673 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14675 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14677 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14679 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14681 encryptedVerifier_pos
++;
14683 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14685 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14687 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14689 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14691 encryptedVerifierHash_pos
++;
14693 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;
14695 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14697 const uint version
= atoi (version_pos
);
14699 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14701 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14703 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14705 const uint keySize
= atoi (keySize_pos
);
14707 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14709 office2007
->keySize
= keySize
;
14711 const uint saltSize
= atoi (saltSize_pos
);
14713 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14719 salt
->salt_len
= 16;
14720 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14722 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14723 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14724 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14725 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14731 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14732 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14733 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14734 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14736 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14737 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14738 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14739 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14740 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14746 digest
[0] = office2007
->encryptedVerifierHash
[0];
14747 digest
[1] = office2007
->encryptedVerifierHash
[1];
14748 digest
[2] = office2007
->encryptedVerifierHash
[2];
14749 digest
[3] = office2007
->encryptedVerifierHash
[3];
14751 return (PARSER_OK
);
14754 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14756 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14758 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14760 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14762 salt_t
*salt
= hash_buf
->salt
;
14764 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14770 char *version_pos
= input_buf
+ 8 + 1;
14772 char *spinCount_pos
= strchr (version_pos
, '*');
14774 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14776 uint32_t version_len
= spinCount_pos
- version_pos
;
14778 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14782 char *keySize_pos
= strchr (spinCount_pos
, '*');
14784 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14786 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14788 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14792 char *saltSize_pos
= strchr (keySize_pos
, '*');
14794 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14796 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14798 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14802 char *osalt_pos
= strchr (saltSize_pos
, '*');
14804 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14806 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14808 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14812 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14814 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14816 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14818 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14820 encryptedVerifier_pos
++;
14822 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14824 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14826 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14828 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14830 encryptedVerifierHash_pos
++;
14832 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;
14834 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14836 const uint version
= atoi (version_pos
);
14838 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14840 const uint spinCount
= atoi (spinCount_pos
);
14842 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14844 const uint keySize
= atoi (keySize_pos
);
14846 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14848 const uint saltSize
= atoi (saltSize_pos
);
14850 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14856 salt
->salt_len
= 16;
14857 salt
->salt_iter
= spinCount
;
14859 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14860 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14861 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14862 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14868 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14869 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14870 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14871 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14873 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14874 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14875 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14876 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14877 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14878 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14879 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14880 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14886 digest
[0] = office2010
->encryptedVerifierHash
[0];
14887 digest
[1] = office2010
->encryptedVerifierHash
[1];
14888 digest
[2] = office2010
->encryptedVerifierHash
[2];
14889 digest
[3] = office2010
->encryptedVerifierHash
[3];
14891 return (PARSER_OK
);
14894 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14896 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14898 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14900 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14902 salt_t
*salt
= hash_buf
->salt
;
14904 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14910 char *version_pos
= input_buf
+ 8 + 1;
14912 char *spinCount_pos
= strchr (version_pos
, '*');
14914 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14916 uint32_t version_len
= spinCount_pos
- version_pos
;
14918 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14922 char *keySize_pos
= strchr (spinCount_pos
, '*');
14924 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14926 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14928 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14932 char *saltSize_pos
= strchr (keySize_pos
, '*');
14934 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14936 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14938 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14942 char *osalt_pos
= strchr (saltSize_pos
, '*');
14944 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14946 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14948 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14952 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14954 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14958 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14960 encryptedVerifier_pos
++;
14962 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14964 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14966 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14968 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14970 encryptedVerifierHash_pos
++;
14972 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;
14974 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14976 const uint version
= atoi (version_pos
);
14978 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14980 const uint spinCount
= atoi (spinCount_pos
);
14982 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14984 const uint keySize
= atoi (keySize_pos
);
14986 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
14988 const uint saltSize
= atoi (saltSize_pos
);
14990 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14996 salt
->salt_len
= 16;
14997 salt
->salt_iter
= spinCount
;
14999 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15000 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15001 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15002 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15008 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15009 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15010 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15011 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15013 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15014 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15015 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15016 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15017 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15018 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15019 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15020 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15026 digest
[0] = office2013
->encryptedVerifierHash
[0];
15027 digest
[1] = office2013
->encryptedVerifierHash
[1];
15028 digest
[2] = office2013
->encryptedVerifierHash
[2];
15029 digest
[3] = office2013
->encryptedVerifierHash
[3];
15031 return (PARSER_OK
);
15034 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15036 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15038 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15040 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15042 salt_t
*salt
= hash_buf
->salt
;
15044 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15050 char *version_pos
= input_buf
+ 11;
15052 char *osalt_pos
= strchr (version_pos
, '*');
15054 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15056 uint32_t version_len
= osalt_pos
- version_pos
;
15058 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15062 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15064 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15066 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15068 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15070 encryptedVerifier_pos
++;
15072 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15074 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15076 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15078 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15080 encryptedVerifierHash_pos
++;
15082 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15084 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15086 const uint version
= *version_pos
- 0x30;
15088 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15094 oldoffice01
->version
= version
;
15096 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15097 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15098 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15099 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15101 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15102 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15103 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15104 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15106 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15107 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15108 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15109 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15111 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15112 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15113 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15114 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15120 salt
->salt_len
= 16;
15122 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15123 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15124 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15125 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15127 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15128 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15129 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15130 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15132 // this is a workaround as office produces multiple documents with the same salt
15134 salt
->salt_len
+= 32;
15136 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15137 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15138 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15139 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15140 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15141 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15142 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15143 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15149 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15150 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15151 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15152 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15154 return (PARSER_OK
);
15157 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15159 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15162 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15164 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15166 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15168 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15170 salt_t
*salt
= hash_buf
->salt
;
15172 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15178 char *version_pos
= input_buf
+ 11;
15180 char *osalt_pos
= strchr (version_pos
, '*');
15182 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15184 uint32_t version_len
= osalt_pos
- version_pos
;
15186 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15190 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15192 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15194 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15196 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15198 encryptedVerifier_pos
++;
15200 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15202 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15204 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15206 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15208 encryptedVerifierHash_pos
++;
15210 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15212 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15214 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15216 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15220 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15222 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15224 const uint version
= *version_pos
- 0x30;
15226 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15232 oldoffice01
->version
= version
;
15234 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15235 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15236 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15237 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15239 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15240 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15241 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15242 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15244 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15245 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15246 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15247 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15249 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15250 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15251 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15252 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15254 oldoffice01
->rc4key
[1] = 0;
15255 oldoffice01
->rc4key
[0] = 0;
15257 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15258 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15259 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15260 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15261 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15262 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15263 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15264 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15265 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15266 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15268 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15269 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15275 salt
->salt_len
= 16;
15277 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15278 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15279 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15280 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15282 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15283 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15284 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15285 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15287 // this is a workaround as office produces multiple documents with the same salt
15289 salt
->salt_len
+= 32;
15291 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15292 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15293 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15294 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15295 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15296 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15297 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15298 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15304 digest
[0] = oldoffice01
->rc4key
[0];
15305 digest
[1] = oldoffice01
->rc4key
[1];
15309 return (PARSER_OK
);
15312 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15314 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15316 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15318 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15320 salt_t
*salt
= hash_buf
->salt
;
15322 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15328 char *version_pos
= input_buf
+ 11;
15330 char *osalt_pos
= strchr (version_pos
, '*');
15332 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15334 uint32_t version_len
= osalt_pos
- version_pos
;
15336 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15340 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15342 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15344 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15346 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15348 encryptedVerifier_pos
++;
15350 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15352 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15354 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15356 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15358 encryptedVerifierHash_pos
++;
15360 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15362 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15364 const uint version
= *version_pos
- 0x30;
15366 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15372 oldoffice34
->version
= version
;
15374 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15375 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15376 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15377 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15379 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15380 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15381 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15382 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15384 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15385 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15386 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15387 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15388 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15390 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15391 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15392 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15393 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15394 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15400 salt
->salt_len
= 16;
15402 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15403 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15404 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15405 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15407 // this is a workaround as office produces multiple documents with the same salt
15409 salt
->salt_len
+= 32;
15411 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15412 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15413 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15414 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15415 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15416 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15417 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15418 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15424 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15425 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15426 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15427 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15429 return (PARSER_OK
);
15432 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15434 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15436 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15439 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15441 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15443 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15445 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15447 salt_t
*salt
= hash_buf
->salt
;
15449 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15455 char *version_pos
= input_buf
+ 11;
15457 char *osalt_pos
= strchr (version_pos
, '*');
15459 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15461 uint32_t version_len
= osalt_pos
- version_pos
;
15463 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15467 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15469 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15471 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15473 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15475 encryptedVerifier_pos
++;
15477 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15479 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15481 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15483 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15485 encryptedVerifierHash_pos
++;
15487 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15489 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15491 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15493 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15497 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15499 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15501 const uint version
= *version_pos
- 0x30;
15503 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15509 oldoffice34
->version
= version
;
15511 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15512 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15513 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15514 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15516 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15517 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15518 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15519 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15521 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15522 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15523 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15524 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15525 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15527 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15528 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15529 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15530 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15531 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15533 oldoffice34
->rc4key
[1] = 0;
15534 oldoffice34
->rc4key
[0] = 0;
15536 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15537 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15538 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15539 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15540 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15541 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15542 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15543 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15544 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15545 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15547 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15548 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15554 salt
->salt_len
= 16;
15556 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15557 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15558 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15559 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15561 // this is a workaround as office produces multiple documents with the same salt
15563 salt
->salt_len
+= 32;
15565 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15566 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15567 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15568 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15569 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15570 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15571 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15572 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15578 digest
[0] = oldoffice34
->rc4key
[0];
15579 digest
[1] = oldoffice34
->rc4key
[1];
15583 return (PARSER_OK
);
15586 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15588 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15590 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15592 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15593 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15594 digest
[2] = hex_to_uint (&input_buf
[16]);
15595 digest
[3] = hex_to_uint (&input_buf
[24]);
15597 digest
[0] = byte_swap_32 (digest
[0]);
15598 digest
[1] = byte_swap_32 (digest
[1]);
15599 digest
[2] = byte_swap_32 (digest
[2]);
15600 digest
[3] = byte_swap_32 (digest
[3]);
15602 return (PARSER_OK
);
15605 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15607 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15609 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15611 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15613 salt_t
*salt
= hash_buf
->salt
;
15615 char *signature_pos
= input_buf
;
15617 char *salt_pos
= strchr (signature_pos
, '$');
15619 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15621 uint32_t signature_len
= salt_pos
- signature_pos
;
15623 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15627 char *hash_pos
= strchr (salt_pos
, '$');
15629 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15631 uint32_t salt_len
= hash_pos
- salt_pos
;
15633 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15637 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15639 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15641 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15642 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15643 digest
[2] = hex_to_uint (&hash_pos
[16]);
15644 digest
[3] = hex_to_uint (&hash_pos
[24]);
15645 digest
[4] = hex_to_uint (&hash_pos
[32]);
15647 digest
[0] -= SHA1M_A
;
15648 digest
[1] -= SHA1M_B
;
15649 digest
[2] -= SHA1M_C
;
15650 digest
[3] -= SHA1M_D
;
15651 digest
[4] -= SHA1M_E
;
15653 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15655 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15657 salt
->salt_len
= salt_len
;
15659 return (PARSER_OK
);
15662 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15664 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15666 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15668 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15670 salt_t
*salt
= hash_buf
->salt
;
15672 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15678 char *iter_pos
= input_buf
+ 14;
15680 const int iter
= atoi (iter_pos
);
15682 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15684 salt
->salt_iter
= iter
- 1;
15686 char *salt_pos
= strchr (iter_pos
, '$');
15688 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15692 char *hash_pos
= strchr (salt_pos
, '$');
15694 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15696 const uint salt_len
= hash_pos
- salt_pos
;
15700 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15702 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15704 salt
->salt_len
= salt_len
;
15706 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15707 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15709 // add some stuff to normal salt to make sorted happy
15711 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15712 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15713 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15714 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15715 salt
->salt_buf
[4] = salt
->salt_iter
;
15717 // base64 decode hash
15721 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15723 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15725 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15727 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15729 memcpy (digest
, tmp_buf
, 32);
15731 digest
[0] = byte_swap_32 (digest
[0]);
15732 digest
[1] = byte_swap_32 (digest
[1]);
15733 digest
[2] = byte_swap_32 (digest
[2]);
15734 digest
[3] = byte_swap_32 (digest
[3]);
15735 digest
[4] = byte_swap_32 (digest
[4]);
15736 digest
[5] = byte_swap_32 (digest
[5]);
15737 digest
[6] = byte_swap_32 (digest
[6]);
15738 digest
[7] = byte_swap_32 (digest
[7]);
15740 return (PARSER_OK
);
15743 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15745 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15747 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15749 salt_t
*salt
= hash_buf
->salt
;
15751 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15752 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15756 digest
[0] = byte_swap_32 (digest
[0]);
15757 digest
[1] = byte_swap_32 (digest
[1]);
15759 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15760 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15761 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15763 char iter_c
= input_buf
[17];
15764 char iter_d
= input_buf
[19];
15766 // atm only defaults, let's see if there's more request
15767 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15768 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15770 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15772 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15773 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15774 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15775 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15777 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15778 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15779 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15780 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15782 salt
->salt_len
= 16;
15784 return (PARSER_OK
);
15787 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15789 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15791 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15793 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15795 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15797 salt_t
*salt
= hash_buf
->salt
;
15799 char *salt_pos
= input_buf
+ 10;
15801 char *hash_pos
= strchr (salt_pos
, '$');
15803 uint salt_len
= hash_pos
- salt_pos
;
15805 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15809 uint hash_len
= input_len
- 10 - salt_len
- 1;
15811 // base64 decode salt
15815 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15817 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15819 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15821 tmp_buf
[salt_len
] = 0x80;
15823 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15825 salt
->salt_len
= salt_len
;
15827 // base64 decode salt
15829 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15831 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15833 uint user_len
= hash_len
- 32;
15835 char *tmp_hash
= tmp_buf
+ user_len
;
15837 user_len
--; // skip the trailing space
15839 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15840 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15841 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15842 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15844 digest
[0] = byte_swap_32 (digest
[0]);
15845 digest
[1] = byte_swap_32 (digest
[1]);
15846 digest
[2] = byte_swap_32 (digest
[2]);
15847 digest
[3] = byte_swap_32 (digest
[3]);
15849 // store username for host only (output hash if cracked)
15851 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15852 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15854 return (PARSER_OK
);
15857 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15859 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15861 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15863 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15865 salt_t
*salt
= hash_buf
->salt
;
15867 char *iter_pos
= input_buf
+ 10;
15869 uint32_t iter
= atoi (iter_pos
);
15873 return (PARSER_SALT_ITERATION
);
15876 iter
--; // first iteration is special
15878 salt
->salt_iter
= iter
;
15880 char *base64_pos
= strchr (iter_pos
, '}');
15882 if (base64_pos
== NULL
)
15884 return (PARSER_SIGNATURE_UNMATCHED
);
15889 // base64 decode salt
15891 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15895 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15897 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15899 if (decoded_len
< 24)
15901 return (PARSER_SALT_LENGTH
);
15906 uint salt_len
= decoded_len
- 20;
15908 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15909 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15911 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15913 salt
->salt_len
= salt_len
;
15917 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15919 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15920 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15921 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15922 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15923 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15925 return (PARSER_OK
);
15928 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15930 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15932 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15934 salt_t
*salt
= hash_buf
->salt
;
15936 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15937 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15938 digest
[2] = hex_to_uint (&input_buf
[16]);
15939 digest
[3] = hex_to_uint (&input_buf
[24]);
15940 digest
[4] = hex_to_uint (&input_buf
[32]);
15942 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15944 uint salt_len
= input_len
- 40 - 1;
15946 char *salt_buf
= input_buf
+ 40 + 1;
15948 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15950 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15952 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15954 salt
->salt_len
= salt_len
;
15956 return (PARSER_OK
);
15959 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15961 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15963 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15965 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15967 salt_t
*salt
= hash_buf
->salt
;
15969 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15975 char *V_pos
= input_buf
+ 5;
15977 char *R_pos
= strchr (V_pos
, '*');
15979 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15981 uint32_t V_len
= R_pos
- V_pos
;
15985 char *bits_pos
= strchr (R_pos
, '*');
15987 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15989 uint32_t R_len
= bits_pos
- R_pos
;
15993 char *P_pos
= strchr (bits_pos
, '*');
15995 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15997 uint32_t bits_len
= P_pos
- bits_pos
;
16001 char *enc_md_pos
= strchr (P_pos
, '*');
16003 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16005 uint32_t P_len
= enc_md_pos
- P_pos
;
16009 char *id_len_pos
= strchr (enc_md_pos
, '*');
16011 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16013 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16017 char *id_buf_pos
= strchr (id_len_pos
, '*');
16019 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16021 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16025 char *u_len_pos
= strchr (id_buf_pos
, '*');
16027 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16029 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16031 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16035 char *u_buf_pos
= strchr (u_len_pos
, '*');
16037 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16039 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16043 char *o_len_pos
= strchr (u_buf_pos
, '*');
16045 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16047 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16049 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16053 char *o_buf_pos
= strchr (o_len_pos
, '*');
16055 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16057 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16061 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;
16063 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16067 const int V
= atoi (V_pos
);
16068 const int R
= atoi (R_pos
);
16069 const int P
= atoi (P_pos
);
16071 if (V
!= 1) return (PARSER_SALT_VALUE
);
16072 if (R
!= 2) return (PARSER_SALT_VALUE
);
16074 const int enc_md
= atoi (enc_md_pos
);
16076 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16078 const int id_len
= atoi (id_len_pos
);
16079 const int u_len
= atoi (u_len_pos
);
16080 const int o_len
= atoi (o_len_pos
);
16082 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16083 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16084 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16086 const int bits
= atoi (bits_pos
);
16088 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16090 // copy data to esalt
16096 pdf
->enc_md
= enc_md
;
16098 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16099 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16100 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16101 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16102 pdf
->id_len
= id_len
;
16104 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16105 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16106 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16107 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16108 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16109 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16110 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16111 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16112 pdf
->u_len
= u_len
;
16114 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16115 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16116 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16117 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16118 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16119 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16120 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16121 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16122 pdf
->o_len
= o_len
;
16124 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16125 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16126 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16127 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16129 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16130 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16131 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16132 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16133 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16134 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16135 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16136 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16138 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16139 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16140 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16141 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16142 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16143 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16144 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16145 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16147 // we use ID for salt, maybe needs to change, we will see...
16149 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16150 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16151 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16152 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16153 salt
->salt_len
= pdf
->id_len
;
16155 digest
[0] = pdf
->u_buf
[0];
16156 digest
[1] = pdf
->u_buf
[1];
16157 digest
[2] = pdf
->u_buf
[2];
16158 digest
[3] = pdf
->u_buf
[3];
16160 return (PARSER_OK
);
16163 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16165 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16168 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16170 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16172 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16174 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16176 salt_t
*salt
= hash_buf
->salt
;
16178 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16184 char *V_pos
= input_buf
+ 5;
16186 char *R_pos
= strchr (V_pos
, '*');
16188 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16190 uint32_t V_len
= R_pos
- V_pos
;
16194 char *bits_pos
= strchr (R_pos
, '*');
16196 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16198 uint32_t R_len
= bits_pos
- R_pos
;
16202 char *P_pos
= strchr (bits_pos
, '*');
16204 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16206 uint32_t bits_len
= P_pos
- bits_pos
;
16210 char *enc_md_pos
= strchr (P_pos
, '*');
16212 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16214 uint32_t P_len
= enc_md_pos
- P_pos
;
16218 char *id_len_pos
= strchr (enc_md_pos
, '*');
16220 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16222 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16226 char *id_buf_pos
= strchr (id_len_pos
, '*');
16228 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16230 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16234 char *u_len_pos
= strchr (id_buf_pos
, '*');
16236 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16238 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16240 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16244 char *u_buf_pos
= strchr (u_len_pos
, '*');
16246 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16248 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16252 char *o_len_pos
= strchr (u_buf_pos
, '*');
16254 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16256 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16258 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16262 char *o_buf_pos
= strchr (o_len_pos
, '*');
16264 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16266 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16270 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16272 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16274 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16276 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16280 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;
16282 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16286 const int V
= atoi (V_pos
);
16287 const int R
= atoi (R_pos
);
16288 const int P
= atoi (P_pos
);
16290 if (V
!= 1) return (PARSER_SALT_VALUE
);
16291 if (R
!= 2) return (PARSER_SALT_VALUE
);
16293 const int enc_md
= atoi (enc_md_pos
);
16295 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16297 const int id_len
= atoi (id_len_pos
);
16298 const int u_len
= atoi (u_len_pos
);
16299 const int o_len
= atoi (o_len_pos
);
16301 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16302 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16303 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16305 const int bits
= atoi (bits_pos
);
16307 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16309 // copy data to esalt
16315 pdf
->enc_md
= enc_md
;
16317 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16318 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16319 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16320 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16321 pdf
->id_len
= id_len
;
16323 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16324 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16325 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16326 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16327 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16328 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16329 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16330 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16331 pdf
->u_len
= u_len
;
16333 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16334 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16335 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16336 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16337 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16338 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16339 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16340 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16341 pdf
->o_len
= o_len
;
16343 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16344 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16345 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16346 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16348 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16349 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16350 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16351 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16352 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16353 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16354 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16355 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16357 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16358 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16359 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16360 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16361 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16362 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16363 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16364 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16366 pdf
->rc4key
[1] = 0;
16367 pdf
->rc4key
[0] = 0;
16369 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16370 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16371 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16372 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16373 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16374 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16375 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16376 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16377 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16378 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16380 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16381 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16383 // we use ID for salt, maybe needs to change, we will see...
16385 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16386 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16387 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16388 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16389 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16390 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16391 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16392 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16393 salt
->salt_len
= pdf
->id_len
+ 16;
16395 digest
[0] = pdf
->rc4key
[0];
16396 digest
[1] = pdf
->rc4key
[1];
16400 return (PARSER_OK
);
16403 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16405 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16407 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16409 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16411 salt_t
*salt
= hash_buf
->salt
;
16413 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16419 char *V_pos
= input_buf
+ 5;
16421 char *R_pos
= strchr (V_pos
, '*');
16423 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16425 uint32_t V_len
= R_pos
- V_pos
;
16429 char *bits_pos
= strchr (R_pos
, '*');
16431 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16433 uint32_t R_len
= bits_pos
- R_pos
;
16437 char *P_pos
= strchr (bits_pos
, '*');
16439 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16441 uint32_t bits_len
= P_pos
- bits_pos
;
16445 char *enc_md_pos
= strchr (P_pos
, '*');
16447 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16449 uint32_t P_len
= enc_md_pos
- P_pos
;
16453 char *id_len_pos
= strchr (enc_md_pos
, '*');
16455 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16457 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16461 char *id_buf_pos
= strchr (id_len_pos
, '*');
16463 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16465 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16469 char *u_len_pos
= strchr (id_buf_pos
, '*');
16471 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16473 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16475 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16479 char *u_buf_pos
= strchr (u_len_pos
, '*');
16481 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16483 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16487 char *o_len_pos
= strchr (u_buf_pos
, '*');
16489 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16491 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16493 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16497 char *o_buf_pos
= strchr (o_len_pos
, '*');
16499 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16501 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16505 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;
16507 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16511 const int V
= atoi (V_pos
);
16512 const int R
= atoi (R_pos
);
16513 const int P
= atoi (P_pos
);
16517 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16518 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16520 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16522 const int id_len
= atoi (id_len_pos
);
16523 const int u_len
= atoi (u_len_pos
);
16524 const int o_len
= atoi (o_len_pos
);
16526 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16528 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16529 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16531 const int bits
= atoi (bits_pos
);
16533 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16539 enc_md
= atoi (enc_md_pos
);
16542 // copy data to esalt
16548 pdf
->enc_md
= enc_md
;
16550 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16551 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16552 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16553 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16557 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16558 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16559 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16560 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16563 pdf
->id_len
= id_len
;
16565 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16566 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16567 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16568 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16569 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16570 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16571 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16572 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16573 pdf
->u_len
= u_len
;
16575 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16576 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16577 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16578 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16579 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16580 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16581 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16582 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16583 pdf
->o_len
= o_len
;
16585 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16586 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16587 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16588 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16592 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16593 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16594 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16595 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16598 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16599 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16600 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16601 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16602 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16603 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16604 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16605 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16607 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16608 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16609 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16610 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16611 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16612 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16613 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16614 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16616 // precompute rc4 data for later use
16632 uint salt_pc_block
[32];
16634 char *salt_pc_ptr
= (char *) salt_pc_block
;
16636 memcpy (salt_pc_ptr
, padding
, 32);
16637 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16639 uint salt_pc_digest
[4];
16641 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16643 pdf
->rc4data
[0] = salt_pc_digest
[0];
16644 pdf
->rc4data
[1] = salt_pc_digest
[1];
16646 // we use ID for salt, maybe needs to change, we will see...
16648 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16649 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16650 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16651 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16652 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16653 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16654 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16655 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16656 salt
->salt_len
= pdf
->id_len
+ 16;
16658 salt
->salt_iter
= ROUNDS_PDF14
;
16660 digest
[0] = pdf
->u_buf
[0];
16661 digest
[1] = pdf
->u_buf
[1];
16665 return (PARSER_OK
);
16668 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16670 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16672 if (ret
!= PARSER_OK
)
16677 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16679 salt_t
*salt
= hash_buf
->salt
;
16681 digest
[0] -= SHA256M_A
;
16682 digest
[1] -= SHA256M_B
;
16683 digest
[2] -= SHA256M_C
;
16684 digest
[3] -= SHA256M_D
;
16685 digest
[4] -= SHA256M_E
;
16686 digest
[5] -= SHA256M_F
;
16687 digest
[6] -= SHA256M_G
;
16688 digest
[7] -= SHA256M_H
;
16690 salt
->salt_buf
[2] = 0x80;
16692 return (PARSER_OK
);
16695 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16697 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16699 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16701 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16703 salt_t
*salt
= hash_buf
->salt
;
16705 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16711 char *V_pos
= input_buf
+ 5;
16713 char *R_pos
= strchr (V_pos
, '*');
16715 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16717 uint32_t V_len
= R_pos
- V_pos
;
16721 char *bits_pos
= strchr (R_pos
, '*');
16723 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16725 uint32_t R_len
= bits_pos
- R_pos
;
16729 char *P_pos
= strchr (bits_pos
, '*');
16731 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16733 uint32_t bits_len
= P_pos
- bits_pos
;
16737 char *enc_md_pos
= strchr (P_pos
, '*');
16739 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16741 uint32_t P_len
= enc_md_pos
- P_pos
;
16745 char *id_len_pos
= strchr (enc_md_pos
, '*');
16747 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16749 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16753 char *id_buf_pos
= strchr (id_len_pos
, '*');
16755 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16757 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16761 char *u_len_pos
= strchr (id_buf_pos
, '*');
16763 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16765 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16769 char *u_buf_pos
= strchr (u_len_pos
, '*');
16771 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16773 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16777 char *o_len_pos
= strchr (u_buf_pos
, '*');
16779 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16781 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16785 char *o_buf_pos
= strchr (o_len_pos
, '*');
16787 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16789 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16793 char *last
= strchr (o_buf_pos
, '*');
16795 if (last
== NULL
) last
= input_buf
+ input_len
;
16797 uint32_t o_buf_len
= last
- o_buf_pos
;
16801 const int V
= atoi (V_pos
);
16802 const int R
= atoi (R_pos
);
16806 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16807 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16809 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16811 const int bits
= atoi (bits_pos
);
16813 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16815 int enc_md
= atoi (enc_md_pos
);
16817 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16819 const uint id_len
= atoi (id_len_pos
);
16820 const uint u_len
= atoi (u_len_pos
);
16821 const uint o_len
= atoi (o_len_pos
);
16823 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16824 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16825 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16826 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16827 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16828 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16829 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16830 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16832 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16833 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16834 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16836 // copy data to esalt
16838 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16840 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16842 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16845 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16846 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16848 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16849 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16851 salt
->salt_len
= 8;
16852 salt
->salt_iter
= ROUNDS_PDF17L8
;
16854 digest
[0] = pdf
->u_buf
[0];
16855 digest
[1] = pdf
->u_buf
[1];
16856 digest
[2] = pdf
->u_buf
[2];
16857 digest
[3] = pdf
->u_buf
[3];
16858 digest
[4] = pdf
->u_buf
[4];
16859 digest
[5] = pdf
->u_buf
[5];
16860 digest
[6] = pdf
->u_buf
[6];
16861 digest
[7] = pdf
->u_buf
[7];
16863 return (PARSER_OK
);
16866 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16868 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16870 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16872 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16874 salt_t
*salt
= hash_buf
->salt
;
16876 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16884 char *iter_pos
= input_buf
+ 7;
16886 uint32_t iter
= atoi (iter_pos
);
16888 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16889 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16891 // first is *raw* salt
16893 char *salt_pos
= strchr (iter_pos
, ':');
16895 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16899 char *hash_pos
= strchr (salt_pos
, ':');
16901 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16903 uint32_t salt_len
= hash_pos
- salt_pos
;
16905 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16909 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16911 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16915 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16921 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16922 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16924 salt
->salt_len
= salt_len
;
16925 salt
->salt_iter
= iter
- 1;
16931 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16933 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16935 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16937 memcpy (digest
, tmp_buf
, 16);
16939 digest
[0] = byte_swap_32 (digest
[0]);
16940 digest
[1] = byte_swap_32 (digest
[1]);
16941 digest
[2] = byte_swap_32 (digest
[2]);
16942 digest
[3] = byte_swap_32 (digest
[3]);
16944 // add some stuff to normal salt to make sorted happy
16946 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16947 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16948 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16949 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16950 salt
->salt_buf
[4] = salt
->salt_iter
;
16952 return (PARSER_OK
);
16955 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16957 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16959 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16961 salt_t
*salt
= hash_buf
->salt
;
16963 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16964 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16965 digest
[2] = hex_to_uint (&input_buf
[16]);
16966 digest
[3] = hex_to_uint (&input_buf
[24]);
16968 digest
[0] = byte_swap_32 (digest
[0]);
16969 digest
[1] = byte_swap_32 (digest
[1]);
16970 digest
[2] = byte_swap_32 (digest
[2]);
16971 digest
[3] = byte_swap_32 (digest
[3]);
16973 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16975 uint salt_len
= input_len
- 32 - 1;
16977 char *salt_buf
= input_buf
+ 32 + 1;
16979 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16981 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16983 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16985 salt
->salt_len
= salt_len
;
16987 return (PARSER_OK
);
16990 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16992 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
16994 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16996 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16998 salt_t
*salt
= hash_buf
->salt
;
17000 char *user_pos
= input_buf
+ 10;
17002 char *salt_pos
= strchr (user_pos
, '*');
17004 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17008 char *hash_pos
= strchr (salt_pos
, '*');
17012 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17014 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17016 uint user_len
= salt_pos
- user_pos
- 1;
17018 uint salt_len
= hash_pos
- salt_pos
- 1;
17020 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17026 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17027 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17028 digest
[2] = hex_to_uint (&hash_pos
[16]);
17029 digest
[3] = hex_to_uint (&hash_pos
[24]);
17031 digest
[0] = byte_swap_32 (digest
[0]);
17032 digest
[1] = byte_swap_32 (digest
[1]);
17033 digest
[2] = byte_swap_32 (digest
[2]);
17034 digest
[3] = byte_swap_32 (digest
[3]);
17036 digest
[0] -= MD5M_A
;
17037 digest
[1] -= MD5M_B
;
17038 digest
[2] -= MD5M_C
;
17039 digest
[3] -= MD5M_D
;
17045 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17047 // first 4 bytes are the "challenge"
17049 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17050 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17051 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17052 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17054 // append the user name
17056 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17058 salt
->salt_len
= 4 + user_len
;
17060 return (PARSER_OK
);
17063 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17065 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17067 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17069 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17071 salt_t
*salt
= hash_buf
->salt
;
17073 char *salt_pos
= input_buf
+ 9;
17075 char *hash_pos
= strchr (salt_pos
, '*');
17077 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17081 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17083 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17085 uint salt_len
= hash_pos
- salt_pos
- 1;
17087 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17093 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17094 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17095 digest
[2] = hex_to_uint (&hash_pos
[16]);
17096 digest
[3] = hex_to_uint (&hash_pos
[24]);
17097 digest
[4] = hex_to_uint (&hash_pos
[32]);
17103 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17105 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17107 salt
->salt_len
= salt_len
;
17109 return (PARSER_OK
);
17112 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17114 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17116 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17118 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17120 salt_t
*salt
= hash_buf
->salt
;
17122 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17128 char *cry_master_len_pos
= input_buf
+ 9;
17130 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17132 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17134 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17136 cry_master_buf_pos
++;
17138 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17140 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17142 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17144 cry_salt_len_pos
++;
17146 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17148 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17150 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17152 cry_salt_buf_pos
++;
17154 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17156 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17158 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17162 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17164 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17166 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17170 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17172 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17174 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17178 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17180 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17182 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17184 public_key_len_pos
++;
17186 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17188 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17190 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17192 public_key_buf_pos
++;
17194 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;
17196 const uint cry_master_len
= atoi (cry_master_len_pos
);
17197 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17198 const uint ckey_len
= atoi (ckey_len_pos
);
17199 const uint public_key_len
= atoi (public_key_len_pos
);
17201 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17202 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17203 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17204 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17206 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17208 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17210 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17213 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17215 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17217 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17220 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17222 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17224 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17227 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17228 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17229 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17232 * store digest (should be unique enought, hopefully)
17235 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17236 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17237 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17238 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17244 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17246 const uint cry_rounds
= atoi (cry_rounds_pos
);
17248 salt
->salt_iter
= cry_rounds
- 1;
17250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17252 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17254 salt
->salt_len
= salt_len
;
17256 return (PARSER_OK
);
17259 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17261 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17263 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17265 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17267 salt_t
*salt
= hash_buf
->salt
;
17269 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17271 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17273 char temp_input_buf
[input_len
+ 1];
17275 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17276 memcpy (temp_input_buf
, input_buf
, input_len
);
17280 char *URI_server_pos
= temp_input_buf
+ 6;
17282 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17284 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17286 URI_client_pos
[0] = 0;
17289 uint URI_server_len
= strlen (URI_server_pos
);
17291 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17295 char *user_pos
= strchr (URI_client_pos
, '*');
17297 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 uint URI_client_len
= strlen (URI_client_pos
);
17304 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17308 char *realm_pos
= strchr (user_pos
, '*');
17310 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17315 uint user_len
= strlen (user_pos
);
17317 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17321 char *method_pos
= strchr (realm_pos
, '*');
17323 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17328 uint realm_len
= strlen (realm_pos
);
17330 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17334 char *URI_prefix_pos
= strchr (method_pos
, '*');
17336 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17338 URI_prefix_pos
[0] = 0;
17341 uint method_len
= strlen (method_pos
);
17343 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17347 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17349 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17351 URI_resource_pos
[0] = 0;
17352 URI_resource_pos
++;
17354 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17356 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17360 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17362 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17364 URI_suffix_pos
[0] = 0;
17367 uint URI_resource_len
= strlen (URI_resource_pos
);
17369 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17370 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17374 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17376 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17381 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17383 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17387 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17389 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17391 nonce_client_pos
[0] = 0;
17392 nonce_client_pos
++;
17394 uint nonce_len
= strlen (nonce_pos
);
17396 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17397 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17401 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17403 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17405 nonce_count_pos
[0] = 0;
17408 uint nonce_client_len
= strlen (nonce_client_pos
);
17410 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17414 char *qop_pos
= strchr (nonce_count_pos
, '*');
17416 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17421 uint nonce_count_len
= strlen (nonce_count_pos
);
17423 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17427 char *directive_pos
= strchr (qop_pos
, '*');
17429 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17431 directive_pos
[0] = 0;
17434 uint qop_len
= strlen (qop_pos
);
17436 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17440 char *digest_pos
= strchr (directive_pos
, '*');
17442 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17447 uint directive_len
= strlen (directive_pos
);
17449 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17451 if (memcmp (directive_pos
, "MD5", 3))
17453 log_info ("ERROR: only the MD5 directive is currently supported\n");
17455 return (PARSER_SIP_AUTH_DIRECTIVE
);
17459 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17464 uint md5_max_len
= 4 * 64;
17466 uint md5_remaining_len
= md5_max_len
;
17468 uint tmp_md5_buf
[md5_max_len
/ 4];
17470 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17472 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17474 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17476 md5_len
+= method_len
+ 1;
17477 tmp_md5_ptr
+= method_len
+ 1;
17479 if (URI_prefix_len
> 0)
17481 md5_remaining_len
= md5_max_len
- md5_len
;
17483 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17485 md5_len
+= URI_prefix_len
+ 1;
17486 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17489 md5_remaining_len
= md5_max_len
- md5_len
;
17491 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17493 md5_len
+= URI_resource_len
;
17494 tmp_md5_ptr
+= URI_resource_len
;
17496 if (URI_suffix_len
> 0)
17498 md5_remaining_len
= md5_max_len
- md5_len
;
17500 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17502 md5_len
+= 1 + URI_suffix_len
;
17505 uint tmp_digest
[4];
17507 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17509 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17510 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17511 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17512 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17518 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17520 uint esalt_len
= 0;
17522 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17524 // there are 2 possibilities for the esalt:
17526 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17528 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17530 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17532 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17544 esalt_len
= 1 + nonce_len
+ 1 + 32;
17546 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17548 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17556 // add 0x80 to esalt
17558 esalt_buf_ptr
[esalt_len
] = 0x80;
17560 sip
->esalt_len
= esalt_len
;
17566 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17568 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17570 uint max_salt_len
= 119;
17572 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17574 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17576 sip
->salt_len
= salt_len
;
17579 * fake salt (for sorting)
17582 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17586 uint fake_salt_len
= salt_len
;
17588 if (fake_salt_len
> max_salt_len
)
17590 fake_salt_len
= max_salt_len
;
17593 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17595 salt
->salt_len
= fake_salt_len
;
17601 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17602 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17603 digest
[2] = hex_to_uint (&digest_pos
[16]);
17604 digest
[3] = hex_to_uint (&digest_pos
[24]);
17606 digest
[0] = byte_swap_32 (digest
[0]);
17607 digest
[1] = byte_swap_32 (digest
[1]);
17608 digest
[2] = byte_swap_32 (digest
[2]);
17609 digest
[3] = byte_swap_32 (digest
[3]);
17611 return (PARSER_OK
);
17614 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17616 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17618 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17620 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17622 salt_t
*salt
= hash_buf
->salt
;
17626 char *digest_pos
= input_buf
;
17628 digest
[0] = hex_to_uint (&digest_pos
[0]);
17635 char *salt_buf
= input_buf
+ 8 + 1;
17639 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17641 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17643 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17645 salt
->salt_len
= salt_len
;
17647 return (PARSER_OK
);
17650 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17652 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17654 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17656 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17658 salt_t
*salt
= hash_buf
->salt
;
17660 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17666 char *p_buf_pos
= input_buf
+ 4;
17668 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17670 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17672 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17674 NumCyclesPower_pos
++;
17676 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17678 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17680 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17684 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17686 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17688 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17692 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17694 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17696 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17700 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17702 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17704 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17708 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17710 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17712 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17716 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17718 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17720 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17724 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17726 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17728 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17732 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17734 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17736 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17740 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;
17742 const uint iter
= atoi (NumCyclesPower_pos
);
17743 const uint crc
= atoi (crc_buf_pos
);
17744 const uint p_buf
= atoi (p_buf_pos
);
17745 const uint salt_len
= atoi (salt_len_pos
);
17746 const uint iv_len
= atoi (iv_len_pos
);
17747 const uint unpack_size
= atoi (unpack_size_pos
);
17748 const uint data_len
= atoi (data_len_pos
);
17754 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17755 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17757 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17759 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17761 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17767 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17768 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17769 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17770 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17772 seven_zip
->iv_len
= iv_len
;
17774 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17776 seven_zip
->salt_len
= 0;
17778 seven_zip
->crc
= crc
;
17780 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17782 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17784 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17787 seven_zip
->data_len
= data_len
;
17789 seven_zip
->unpack_size
= unpack_size
;
17793 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17794 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17795 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17796 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17798 salt
->salt_len
= 16;
17800 salt
->salt_sign
[0] = iter
;
17802 salt
->salt_iter
= 1 << iter
;
17813 return (PARSER_OK
);
17816 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17818 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17820 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17822 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17823 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17824 digest
[2] = hex_to_uint (&input_buf
[16]);
17825 digest
[3] = hex_to_uint (&input_buf
[24]);
17826 digest
[4] = hex_to_uint (&input_buf
[32]);
17827 digest
[5] = hex_to_uint (&input_buf
[40]);
17828 digest
[6] = hex_to_uint (&input_buf
[48]);
17829 digest
[7] = hex_to_uint (&input_buf
[56]);
17831 digest
[0] = byte_swap_32 (digest
[0]);
17832 digest
[1] = byte_swap_32 (digest
[1]);
17833 digest
[2] = byte_swap_32 (digest
[2]);
17834 digest
[3] = byte_swap_32 (digest
[3]);
17835 digest
[4] = byte_swap_32 (digest
[4]);
17836 digest
[5] = byte_swap_32 (digest
[5]);
17837 digest
[6] = byte_swap_32 (digest
[6]);
17838 digest
[7] = byte_swap_32 (digest
[7]);
17840 return (PARSER_OK
);
17843 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17845 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17847 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17849 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17850 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17851 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17852 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17853 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17854 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17855 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17856 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17857 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17858 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17859 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17860 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17861 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17862 digest
[13] = hex_to_uint (&input_buf
[104]);
17863 digest
[14] = hex_to_uint (&input_buf
[112]);
17864 digest
[15] = hex_to_uint (&input_buf
[120]);
17866 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17867 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17868 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17869 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17870 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17871 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17872 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17873 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17874 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17875 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17876 digest
[10] = byte_swap_32 (digest
[10]);
17877 digest
[11] = byte_swap_32 (digest
[11]);
17878 digest
[12] = byte_swap_32 (digest
[12]);
17879 digest
[13] = byte_swap_32 (digest
[13]);
17880 digest
[14] = byte_swap_32 (digest
[14]);
17881 digest
[15] = byte_swap_32 (digest
[15]);
17883 return (PARSER_OK
);
17886 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17888 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17890 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17892 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17894 salt_t
*salt
= hash_buf
->salt
;
17896 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17904 char *iter_pos
= input_buf
+ 4;
17906 uint32_t iter
= atoi (iter_pos
);
17908 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17909 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17911 // first is *raw* salt
17913 char *salt_pos
= strchr (iter_pos
, ':');
17915 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17919 char *hash_pos
= strchr (salt_pos
, ':');
17921 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17923 uint32_t salt_len
= hash_pos
- salt_pos
;
17925 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17929 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17931 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17935 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17937 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17941 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17942 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17944 salt
->salt_len
= salt_len
;
17945 salt
->salt_iter
= iter
- 1;
17951 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17953 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17955 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17957 memcpy (digest
, tmp_buf
, 16);
17959 // add some stuff to normal salt to make sorted happy
17961 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17962 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17963 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17964 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17965 salt
->salt_buf
[4] = salt
->salt_iter
;
17967 return (PARSER_OK
);
17970 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17972 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17974 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17976 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17978 salt_t
*salt
= hash_buf
->salt
;
17980 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
17988 char *iter_pos
= input_buf
+ 5;
17990 uint32_t iter
= atoi (iter_pos
);
17992 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17993 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17995 // first is *raw* salt
17997 char *salt_pos
= strchr (iter_pos
, ':');
17999 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18003 char *hash_pos
= strchr (salt_pos
, ':');
18005 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18007 uint32_t salt_len
= hash_pos
- salt_pos
;
18009 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18013 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18015 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18019 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18021 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18023 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18025 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18026 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18028 salt
->salt_len
= salt_len
;
18029 salt
->salt_iter
= iter
- 1;
18035 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18037 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18039 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18041 memcpy (digest
, tmp_buf
, 16);
18043 digest
[0] = byte_swap_32 (digest
[0]);
18044 digest
[1] = byte_swap_32 (digest
[1]);
18045 digest
[2] = byte_swap_32 (digest
[2]);
18046 digest
[3] = byte_swap_32 (digest
[3]);
18048 // add some stuff to normal salt to make sorted happy
18050 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18051 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18052 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18053 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18054 salt
->salt_buf
[4] = salt
->salt_iter
;
18056 return (PARSER_OK
);
18059 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18061 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18063 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18065 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18067 salt_t
*salt
= hash_buf
->salt
;
18069 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18077 char *iter_pos
= input_buf
+ 7;
18079 uint32_t iter
= atoi (iter_pos
);
18081 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18082 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18084 // first is *raw* salt
18086 char *salt_pos
= strchr (iter_pos
, ':');
18088 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18092 char *hash_pos
= strchr (salt_pos
, ':');
18094 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18096 uint32_t salt_len
= hash_pos
- salt_pos
;
18098 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18102 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18104 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18108 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18114 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18115 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18117 salt
->salt_len
= salt_len
;
18118 salt
->salt_iter
= iter
- 1;
18124 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18126 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18128 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18130 memcpy (digest
, tmp_buf
, 64);
18132 digest
[0] = byte_swap_64 (digest
[0]);
18133 digest
[1] = byte_swap_64 (digest
[1]);
18134 digest
[2] = byte_swap_64 (digest
[2]);
18135 digest
[3] = byte_swap_64 (digest
[3]);
18136 digest
[4] = byte_swap_64 (digest
[4]);
18137 digest
[5] = byte_swap_64 (digest
[5]);
18138 digest
[6] = byte_swap_64 (digest
[6]);
18139 digest
[7] = byte_swap_64 (digest
[7]);
18141 // add some stuff to normal salt to make sorted happy
18143 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18144 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18145 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18146 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18147 salt
->salt_buf
[4] = salt
->salt_iter
;
18149 return (PARSER_OK
);
18152 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18154 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18156 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18158 uint
*digest
= (uint
*) hash_buf
->digest
;
18160 salt_t
*salt
= hash_buf
->salt
;
18166 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18168 char *hash_pos
= strchr (salt_pos
, '$');
18170 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18172 uint32_t salt_len
= hash_pos
- salt_pos
;
18174 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18178 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18180 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18184 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18185 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18203 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18204 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18206 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18207 salt
->salt_len
= 8;
18209 return (PARSER_OK
);
18212 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18214 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18216 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18218 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18220 if (c19
& 3) return (PARSER_HASH_VALUE
);
18222 salt_t
*salt
= hash_buf
->salt
;
18224 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18228 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18229 | itoa64_to_int (input_buf
[2]) << 6
18230 | itoa64_to_int (input_buf
[3]) << 12
18231 | itoa64_to_int (input_buf
[4]) << 18;
18235 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18236 | itoa64_to_int (input_buf
[6]) << 6
18237 | itoa64_to_int (input_buf
[7]) << 12
18238 | itoa64_to_int (input_buf
[8]) << 18;
18240 salt
->salt_len
= 4;
18244 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18246 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18248 memcpy (digest
, tmp_buf
, 8);
18252 IP (digest
[0], digest
[1], tt
);
18254 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18255 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18259 return (PARSER_OK
);
18262 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18264 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18266 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18268 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18270 salt_t
*salt
= hash_buf
->salt
;
18276 char *type_pos
= input_buf
+ 6 + 1;
18278 char *salt_pos
= strchr (type_pos
, '*');
18280 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18282 uint32_t type_len
= salt_pos
- type_pos
;
18284 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18288 char *crypted_pos
= strchr (salt_pos
, '*');
18290 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18292 uint32_t salt_len
= crypted_pos
- salt_pos
;
18294 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18298 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18300 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18306 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18307 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18309 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18310 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18312 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18313 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18314 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18315 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18317 salt
->salt_len
= 24;
18318 salt
->salt_iter
= ROUNDS_RAR3
;
18320 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18321 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18323 digest
[0] = 0xc43d7b00;
18324 digest
[1] = 0x40070000;
18328 return (PARSER_OK
);
18331 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18333 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18335 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18337 salt_t
*salt
= hash_buf
->salt
;
18339 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18340 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18341 digest
[2] = hex_to_uint (&input_buf
[16]);
18342 digest
[3] = hex_to_uint (&input_buf
[24]);
18343 digest
[4] = hex_to_uint (&input_buf
[32]);
18344 digest
[5] = hex_to_uint (&input_buf
[40]);
18345 digest
[6] = hex_to_uint (&input_buf
[48]);
18346 digest
[7] = hex_to_uint (&input_buf
[56]);
18348 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18350 uint salt_len
= input_len
- 64 - 1;
18352 char *salt_buf
= input_buf
+ 64 + 1;
18354 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18356 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18358 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18360 salt
->salt_len
= salt_len
;
18363 * we can precompute the first sha256 transform
18368 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18369 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18370 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18371 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18372 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18373 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18374 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18375 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18376 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18377 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18378 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18379 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18380 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18381 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18382 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18383 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18387 pc256
[0] = SHA256M_A
;
18388 pc256
[1] = SHA256M_B
;
18389 pc256
[2] = SHA256M_C
;
18390 pc256
[3] = SHA256M_D
;
18391 pc256
[4] = SHA256M_E
;
18392 pc256
[5] = SHA256M_F
;
18393 pc256
[6] = SHA256M_G
;
18394 pc256
[7] = SHA256M_H
;
18396 sha256_64 (w
, pc256
);
18398 salt
->salt_buf_pc
[0] = pc256
[0];
18399 salt
->salt_buf_pc
[1] = pc256
[1];
18400 salt
->salt_buf_pc
[2] = pc256
[2];
18401 salt
->salt_buf_pc
[3] = pc256
[3];
18402 salt
->salt_buf_pc
[4] = pc256
[4];
18403 salt
->salt_buf_pc
[5] = pc256
[5];
18404 salt
->salt_buf_pc
[6] = pc256
[6];
18405 salt
->salt_buf_pc
[7] = pc256
[7];
18407 digest
[0] -= pc256
[0];
18408 digest
[1] -= pc256
[1];
18409 digest
[2] -= pc256
[2];
18410 digest
[3] -= pc256
[3];
18411 digest
[4] -= pc256
[4];
18412 digest
[5] -= pc256
[5];
18413 digest
[6] -= pc256
[6];
18414 digest
[7] -= pc256
[7];
18416 return (PARSER_OK
);
18419 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18421 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18423 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18425 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18427 salt_t
*salt
= hash_buf
->salt
;
18433 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18435 char *data_buf_pos
= strchr (data_len_pos
, '$');
18437 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18439 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18441 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18442 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18446 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18448 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18450 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18452 uint32_t data_len
= atoi (data_len_pos
);
18454 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18460 char *salt_pos
= data_buf_pos
;
18462 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18463 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18464 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18465 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18467 // this is actually the CT, which is also the hash later (if matched)
18469 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18470 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18471 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18472 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18474 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18476 salt
->salt_iter
= 10 - 1;
18482 digest
[0] = salt
->salt_buf
[4];
18483 digest
[1] = salt
->salt_buf
[5];
18484 digest
[2] = salt
->salt_buf
[6];
18485 digest
[3] = salt
->salt_buf
[7];
18487 return (PARSER_OK
);
18490 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18492 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18494 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18496 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18498 salt_t
*salt
= hash_buf
->salt
;
18504 char *salt_pos
= input_buf
+ 11 + 1;
18506 char *iter_pos
= strchr (salt_pos
, ',');
18508 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18510 uint32_t salt_len
= iter_pos
- salt_pos
;
18512 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18516 char *hash_pos
= strchr (iter_pos
, ',');
18518 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18520 uint32_t iter_len
= hash_pos
- iter_pos
;
18522 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18526 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18528 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18534 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18535 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18536 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18537 salt
->salt_buf
[3] = 0x00018000;
18539 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18540 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18541 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18542 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18544 salt
->salt_len
= salt_len
/ 2;
18546 salt
->salt_iter
= atoi (iter_pos
) - 1;
18552 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18553 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18554 digest
[2] = hex_to_uint (&hash_pos
[16]);
18555 digest
[3] = hex_to_uint (&hash_pos
[24]);
18556 digest
[4] = hex_to_uint (&hash_pos
[32]);
18557 digest
[5] = hex_to_uint (&hash_pos
[40]);
18558 digest
[6] = hex_to_uint (&hash_pos
[48]);
18559 digest
[7] = hex_to_uint (&hash_pos
[56]);
18561 return (PARSER_OK
);
18565 * parallel running threads
18570 BOOL WINAPI
sigHandler_default (DWORD sig
)
18574 case CTRL_CLOSE_EVENT
:
18577 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18578 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18579 * function otherwise it is to late (e.g. after returning from this function)
18584 SetConsoleCtrlHandler (NULL
, TRUE
);
18591 case CTRL_LOGOFF_EVENT
:
18592 case CTRL_SHUTDOWN_EVENT
:
18596 SetConsoleCtrlHandler (NULL
, TRUE
);
18604 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18608 case CTRL_CLOSE_EVENT
:
18612 SetConsoleCtrlHandler (NULL
, TRUE
);
18619 case CTRL_LOGOFF_EVENT
:
18620 case CTRL_SHUTDOWN_EVENT
:
18624 SetConsoleCtrlHandler (NULL
, TRUE
);
18632 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18634 if (callback
== NULL
)
18636 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18640 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18646 void sigHandler_default (int sig
)
18650 signal (sig
, NULL
);
18653 void sigHandler_benchmark (int sig
)
18657 signal (sig
, NULL
);
18660 void hc_signal (void (callback
) (int))
18662 if (callback
== NULL
) callback
= SIG_DFL
;
18664 signal (SIGINT
, callback
);
18665 signal (SIGTERM
, callback
);
18666 signal (SIGABRT
, callback
);
18671 void status_display ();
18673 void *thread_keypress (void *p
)
18675 int benchmark
= *((int *) p
);
18677 uint quiet
= data
.quiet
;
18681 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18683 int ch
= tty_getchar();
18685 if (ch
== -1) break;
18687 if (ch
== 0) continue;
18693 hc_thread_mutex_lock (mux_display
);
18708 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18709 if (quiet
== 0) fflush (stdout
);
18721 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18722 if (quiet
== 0) fflush (stdout
);
18734 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18735 if (quiet
== 0) fflush (stdout
);
18747 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18748 if (quiet
== 0) fflush (stdout
);
18756 if (benchmark
== 1) break;
18758 stop_at_checkpoint ();
18762 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18763 if (quiet
== 0) fflush (stdout
);
18771 if (benchmark
== 1)
18783 hc_thread_mutex_unlock (mux_display
);
18795 bool class_num (char c
)
18797 return ((c
>= '0') && (c
<= '9'));
18800 bool class_lower (char c
)
18802 return ((c
>= 'a') && (c
<= 'z'));
18805 bool class_upper (char c
)
18807 return ((c
>= 'A') && (c
<= 'Z'));
18810 bool class_alpha (char c
)
18812 return (class_lower (c
) || class_upper (c
));
18815 char conv_ctoi (char c
)
18821 else if (class_upper (c
))
18823 return c
- 'A' + (char) 10;
18826 return (char) (-1);
18829 char conv_itoc (char c
)
18837 return c
+ 'A' - (char) 10;
18840 return (char) (-1);
18847 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18848 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18849 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18850 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18851 #define MAX_GPU_RULES 14
18852 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18853 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18854 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18856 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18857 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18858 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18859 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18861 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18866 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18868 switch (rule_buf
[rule_pos
])
18874 case RULE_OP_MANGLE_NOOP
:
18875 SET_NAME (rule
, rule_buf
[rule_pos
]);
18878 case RULE_OP_MANGLE_LREST
:
18879 SET_NAME (rule
, rule_buf
[rule_pos
]);
18882 case RULE_OP_MANGLE_UREST
:
18883 SET_NAME (rule
, rule_buf
[rule_pos
]);
18886 case RULE_OP_MANGLE_LREST_UFIRST
:
18887 SET_NAME (rule
, rule_buf
[rule_pos
]);
18890 case RULE_OP_MANGLE_UREST_LFIRST
:
18891 SET_NAME (rule
, rule_buf
[rule_pos
]);
18894 case RULE_OP_MANGLE_TREST
:
18895 SET_NAME (rule
, rule_buf
[rule_pos
]);
18898 case RULE_OP_MANGLE_TOGGLE_AT
:
18899 SET_NAME (rule
, rule_buf
[rule_pos
]);
18900 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18903 case RULE_OP_MANGLE_REVERSE
:
18904 SET_NAME (rule
, rule_buf
[rule_pos
]);
18907 case RULE_OP_MANGLE_DUPEWORD
:
18908 SET_NAME (rule
, rule_buf
[rule_pos
]);
18911 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18912 SET_NAME (rule
, rule_buf
[rule_pos
]);
18913 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18916 case RULE_OP_MANGLE_REFLECT
:
18917 SET_NAME (rule
, rule_buf
[rule_pos
]);
18920 case RULE_OP_MANGLE_ROTATE_LEFT
:
18921 SET_NAME (rule
, rule_buf
[rule_pos
]);
18924 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18925 SET_NAME (rule
, rule_buf
[rule_pos
]);
18928 case RULE_OP_MANGLE_APPEND
:
18929 SET_NAME (rule
, rule_buf
[rule_pos
]);
18930 SET_P0 (rule
, rule_buf
[rule_pos
]);
18933 case RULE_OP_MANGLE_PREPEND
:
18934 SET_NAME (rule
, rule_buf
[rule_pos
]);
18935 SET_P0 (rule
, rule_buf
[rule_pos
]);
18938 case RULE_OP_MANGLE_DELETE_FIRST
:
18939 SET_NAME (rule
, rule_buf
[rule_pos
]);
18942 case RULE_OP_MANGLE_DELETE_LAST
:
18943 SET_NAME (rule
, rule_buf
[rule_pos
]);
18946 case RULE_OP_MANGLE_DELETE_AT
:
18947 SET_NAME (rule
, rule_buf
[rule_pos
]);
18948 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18951 case RULE_OP_MANGLE_EXTRACT
:
18952 SET_NAME (rule
, rule_buf
[rule_pos
]);
18953 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18954 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18957 case RULE_OP_MANGLE_OMIT
:
18958 SET_NAME (rule
, rule_buf
[rule_pos
]);
18959 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18960 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18963 case RULE_OP_MANGLE_INSERT
:
18964 SET_NAME (rule
, rule_buf
[rule_pos
]);
18965 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18966 SET_P1 (rule
, rule_buf
[rule_pos
]);
18969 case RULE_OP_MANGLE_OVERSTRIKE
:
18970 SET_NAME (rule
, rule_buf
[rule_pos
]);
18971 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18972 SET_P1 (rule
, rule_buf
[rule_pos
]);
18975 case RULE_OP_MANGLE_TRUNCATE_AT
:
18976 SET_NAME (rule
, rule_buf
[rule_pos
]);
18977 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18980 case RULE_OP_MANGLE_REPLACE
:
18981 SET_NAME (rule
, rule_buf
[rule_pos
]);
18982 SET_P0 (rule
, rule_buf
[rule_pos
]);
18983 SET_P1 (rule
, rule_buf
[rule_pos
]);
18986 case RULE_OP_MANGLE_PURGECHAR
:
18990 case RULE_OP_MANGLE_TOGGLECASE_REC
:
18994 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
18995 SET_NAME (rule
, rule_buf
[rule_pos
]);
18996 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18999 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19000 SET_NAME (rule
, rule_buf
[rule_pos
]);
19001 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19004 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19005 SET_NAME (rule
, rule_buf
[rule_pos
]);
19008 case RULE_OP_MANGLE_SWITCH_FIRST
:
19009 SET_NAME (rule
, rule_buf
[rule_pos
]);
19012 case RULE_OP_MANGLE_SWITCH_LAST
:
19013 SET_NAME (rule
, rule_buf
[rule_pos
]);
19016 case RULE_OP_MANGLE_SWITCH_AT
:
19017 SET_NAME (rule
, rule_buf
[rule_pos
]);
19018 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19019 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19022 case RULE_OP_MANGLE_CHR_SHIFTL
:
19023 SET_NAME (rule
, rule_buf
[rule_pos
]);
19024 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19027 case RULE_OP_MANGLE_CHR_SHIFTR
:
19028 SET_NAME (rule
, rule_buf
[rule_pos
]);
19029 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19032 case RULE_OP_MANGLE_CHR_INCR
:
19033 SET_NAME (rule
, rule_buf
[rule_pos
]);
19034 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19037 case RULE_OP_MANGLE_CHR_DECR
:
19038 SET_NAME (rule
, rule_buf
[rule_pos
]);
19039 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19042 case RULE_OP_MANGLE_REPLACE_NP1
:
19043 SET_NAME (rule
, rule_buf
[rule_pos
]);
19044 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19047 case RULE_OP_MANGLE_REPLACE_NM1
:
19048 SET_NAME (rule
, rule_buf
[rule_pos
]);
19049 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19052 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19053 SET_NAME (rule
, rule_buf
[rule_pos
]);
19054 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19057 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19058 SET_NAME (rule
, rule_buf
[rule_pos
]);
19059 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19062 case RULE_OP_MANGLE_TITLE
:
19063 SET_NAME (rule
, rule_buf
[rule_pos
]);
19072 if (rule_pos
< rule_len
) return (-1);
19077 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19081 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19085 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19089 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19093 case RULE_OP_MANGLE_NOOP
:
19094 rule_buf
[rule_pos
] = rule_cmd
;
19097 case RULE_OP_MANGLE_LREST
:
19098 rule_buf
[rule_pos
] = rule_cmd
;
19101 case RULE_OP_MANGLE_UREST
:
19102 rule_buf
[rule_pos
] = rule_cmd
;
19105 case RULE_OP_MANGLE_LREST_UFIRST
:
19106 rule_buf
[rule_pos
] = rule_cmd
;
19109 case RULE_OP_MANGLE_UREST_LFIRST
:
19110 rule_buf
[rule_pos
] = rule_cmd
;
19113 case RULE_OP_MANGLE_TREST
:
19114 rule_buf
[rule_pos
] = rule_cmd
;
19117 case RULE_OP_MANGLE_TOGGLE_AT
:
19118 rule_buf
[rule_pos
] = rule_cmd
;
19119 GET_P0_CONV (rule
);
19122 case RULE_OP_MANGLE_REVERSE
:
19123 rule_buf
[rule_pos
] = rule_cmd
;
19126 case RULE_OP_MANGLE_DUPEWORD
:
19127 rule_buf
[rule_pos
] = rule_cmd
;
19130 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19131 rule_buf
[rule_pos
] = rule_cmd
;
19132 GET_P0_CONV (rule
);
19135 case RULE_OP_MANGLE_REFLECT
:
19136 rule_buf
[rule_pos
] = rule_cmd
;
19139 case RULE_OP_MANGLE_ROTATE_LEFT
:
19140 rule_buf
[rule_pos
] = rule_cmd
;
19143 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19144 rule_buf
[rule_pos
] = rule_cmd
;
19147 case RULE_OP_MANGLE_APPEND
:
19148 rule_buf
[rule_pos
] = rule_cmd
;
19152 case RULE_OP_MANGLE_PREPEND
:
19153 rule_buf
[rule_pos
] = rule_cmd
;
19157 case RULE_OP_MANGLE_DELETE_FIRST
:
19158 rule_buf
[rule_pos
] = rule_cmd
;
19161 case RULE_OP_MANGLE_DELETE_LAST
:
19162 rule_buf
[rule_pos
] = rule_cmd
;
19165 case RULE_OP_MANGLE_DELETE_AT
:
19166 rule_buf
[rule_pos
] = rule_cmd
;
19167 GET_P0_CONV (rule
);
19170 case RULE_OP_MANGLE_EXTRACT
:
19171 rule_buf
[rule_pos
] = rule_cmd
;
19172 GET_P0_CONV (rule
);
19173 GET_P1_CONV (rule
);
19176 case RULE_OP_MANGLE_OMIT
:
19177 rule_buf
[rule_pos
] = rule_cmd
;
19178 GET_P0_CONV (rule
);
19179 GET_P1_CONV (rule
);
19182 case RULE_OP_MANGLE_INSERT
:
19183 rule_buf
[rule_pos
] = rule_cmd
;
19184 GET_P0_CONV (rule
);
19188 case RULE_OP_MANGLE_OVERSTRIKE
:
19189 rule_buf
[rule_pos
] = rule_cmd
;
19190 GET_P0_CONV (rule
);
19194 case RULE_OP_MANGLE_TRUNCATE_AT
:
19195 rule_buf
[rule_pos
] = rule_cmd
;
19196 GET_P0_CONV (rule
);
19199 case RULE_OP_MANGLE_REPLACE
:
19200 rule_buf
[rule_pos
] = rule_cmd
;
19205 case RULE_OP_MANGLE_PURGECHAR
:
19209 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19213 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19214 rule_buf
[rule_pos
] = rule_cmd
;
19215 GET_P0_CONV (rule
);
19218 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19219 rule_buf
[rule_pos
] = rule_cmd
;
19220 GET_P0_CONV (rule
);
19223 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19224 rule_buf
[rule_pos
] = rule_cmd
;
19227 case RULE_OP_MANGLE_SWITCH_FIRST
:
19228 rule_buf
[rule_pos
] = rule_cmd
;
19231 case RULE_OP_MANGLE_SWITCH_LAST
:
19232 rule_buf
[rule_pos
] = rule_cmd
;
19235 case RULE_OP_MANGLE_SWITCH_AT
:
19236 rule_buf
[rule_pos
] = rule_cmd
;
19237 GET_P0_CONV (rule
);
19238 GET_P1_CONV (rule
);
19241 case RULE_OP_MANGLE_CHR_SHIFTL
:
19242 rule_buf
[rule_pos
] = rule_cmd
;
19243 GET_P0_CONV (rule
);
19246 case RULE_OP_MANGLE_CHR_SHIFTR
:
19247 rule_buf
[rule_pos
] = rule_cmd
;
19248 GET_P0_CONV (rule
);
19251 case RULE_OP_MANGLE_CHR_INCR
:
19252 rule_buf
[rule_pos
] = rule_cmd
;
19253 GET_P0_CONV (rule
);
19256 case RULE_OP_MANGLE_CHR_DECR
:
19257 rule_buf
[rule_pos
] = rule_cmd
;
19258 GET_P0_CONV (rule
);
19261 case RULE_OP_MANGLE_REPLACE_NP1
:
19262 rule_buf
[rule_pos
] = rule_cmd
;
19263 GET_P0_CONV (rule
);
19266 case RULE_OP_MANGLE_REPLACE_NM1
:
19267 rule_buf
[rule_pos
] = rule_cmd
;
19268 GET_P0_CONV (rule
);
19271 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19272 rule_buf
[rule_pos
] = rule_cmd
;
19273 GET_P0_CONV (rule
);
19276 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19277 rule_buf
[rule_pos
] = rule_cmd
;
19278 GET_P0_CONV (rule
);
19281 case RULE_OP_MANGLE_TITLE
:
19282 rule_buf
[rule_pos
] = rule_cmd
;
19286 return rule_pos
- 1;
19304 * CPU rules : this is from hashcat sources, cpu based rules
19307 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19308 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19310 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19311 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19312 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19314 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19315 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19316 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19318 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19322 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19327 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19331 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19336 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19340 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19345 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19350 for (l
= 0; l
< arr_len
; l
++)
19352 r
= arr_len
- 1 - l
;
19356 MANGLE_SWITCH (arr
, l
, r
);
19362 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19364 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19366 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19368 return (arr_len
* 2);
19371 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19373 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19375 int orig_len
= arr_len
;
19379 for (i
= 0; i
< times
; i
++)
19381 memcpy (&arr
[arr_len
], arr
, orig_len
);
19383 arr_len
+= orig_len
;
19389 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19391 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19393 mangle_double (arr
, arr_len
);
19395 mangle_reverse (arr
+ arr_len
, arr_len
);
19397 return (arr_len
* 2);
19400 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19405 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19407 MANGLE_SWITCH (arr
, l
, r
);
19413 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19418 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19420 MANGLE_SWITCH (arr
, l
, r
);
19426 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19428 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19432 return (arr_len
+ 1);
19435 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19437 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19441 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19443 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19448 return (arr_len
+ 1);
19451 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19453 if (upos
>= arr_len
) return (arr_len
);
19457 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19459 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19462 return (arr_len
- 1);
19465 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19467 if (upos
>= arr_len
) return (arr_len
);
19469 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19473 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19475 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19481 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19483 if (upos
>= arr_len
) return (arr_len
);
19485 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19489 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19491 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19494 return (arr_len
- ulen
);
19497 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19499 if (upos
>= arr_len
) return (arr_len
);
19501 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19505 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19507 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19512 return (arr_len
+ 1);
19515 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
)
19517 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19519 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19521 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19523 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19525 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19527 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19529 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19531 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19533 return (arr_len
+ arr2_cpy
);
19536 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19538 if (upos
>= arr_len
) return (arr_len
);
19545 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19547 if (upos
>= arr_len
) return (arr_len
);
19549 memset (arr
+ upos
, 0, arr_len
- upos
);
19554 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19558 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19560 if (arr
[arr_pos
] != oldc
) continue;
19562 arr
[arr_pos
] = newc
;
19568 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19574 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19576 if (arr
[arr_pos
] == c
) continue;
19578 arr
[ret_len
] = arr
[arr_pos
];
19586 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19588 if (ulen
> arr_len
) return (arr_len
);
19590 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19594 memcpy (cs
, arr
, ulen
);
19598 for (i
= 0; i
< ulen
; i
++)
19602 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19608 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19610 if (ulen
> arr_len
) return (arr_len
);
19612 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19614 int upos
= arr_len
- ulen
;
19618 for (i
= 0; i
< ulen
; i
++)
19620 char c
= arr
[upos
+ i
];
19622 arr_len
= mangle_append (arr
, arr_len
, c
);
19628 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19630 if ( arr_len
== 0) return (arr_len
);
19631 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19633 char c
= arr
[upos
];
19637 for (i
= 0; i
< ulen
; i
++)
19639 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19645 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19647 if ( arr_len
== 0) return (arr_len
);
19648 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19652 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19654 int new_pos
= arr_pos
* 2;
19656 arr
[new_pos
] = arr
[arr_pos
];
19658 arr
[new_pos
+ 1] = arr
[arr_pos
];
19661 return (arr_len
* 2);
19664 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19666 if (upos
>= arr_len
) return (arr_len
);
19667 if (upos2
>= arr_len
) return (arr_len
);
19669 MANGLE_SWITCH (arr
, upos
, upos2
);
19674 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19676 MANGLE_SWITCH (arr
, upos
, upos2
);
19681 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19683 if (upos
>= arr_len
) return (arr_len
);
19690 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19692 if (upos
>= arr_len
) return (arr_len
);
19699 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19701 if (upos
>= arr_len
) return (arr_len
);
19708 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19710 if (upos
>= arr_len
) return (arr_len
);
19717 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19719 int upper_next
= 1;
19723 for (pos
= 0; pos
< arr_len
; pos
++)
19725 if (arr
[pos
] == ' ')
19736 MANGLE_UPPER_AT (arr
, pos
);
19740 MANGLE_LOWER_AT (arr
, pos
);
19747 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19749 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19753 uint32_t rule_pos
= 0;
19755 for (j
= 0; j
< rp_gen_num
; j
++)
19762 switch ((char) get_random_num (0, 9))
19765 r
= get_random_num (0, sizeof (grp_op_nop
));
19766 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19770 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19771 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19772 p1
= get_random_num (0, sizeof (grp_pos
));
19773 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19777 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19778 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19779 p1
= get_random_num (1, 6);
19780 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19784 r
= get_random_num (0, sizeof (grp_op_chr
));
19785 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19786 p1
= get_random_num (0x20, 0x7e);
19787 rule_buf
[rule_pos
++] = (char) p1
;
19791 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19792 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19793 p1
= get_random_num (0x20, 0x7e);
19794 rule_buf
[rule_pos
++] = (char) p1
;
19795 p2
= get_random_num (0x20, 0x7e);
19797 p2
= get_random_num (0x20, 0x7e);
19798 rule_buf
[rule_pos
++] = (char) p2
;
19802 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19803 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19804 p1
= get_random_num (0, sizeof (grp_pos
));
19805 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19806 p2
= get_random_num (0x20, 0x7e);
19807 rule_buf
[rule_pos
++] = (char) p2
;
19811 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19812 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19813 p1
= get_random_num (0, sizeof (grp_pos
));
19814 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19815 p2
= get_random_num (0, sizeof (grp_pos
));
19817 p2
= get_random_num (0, sizeof (grp_pos
));
19818 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19822 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19823 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19824 p1
= get_random_num (0, sizeof (grp_pos
));
19825 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19826 p2
= get_random_num (1, sizeof (grp_pos
));
19828 p2
= get_random_num (1, sizeof (grp_pos
));
19829 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19833 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19834 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19835 p1
= get_random_num (0, sizeof (grp_pos
));
19836 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19837 p2
= get_random_num (1, sizeof (grp_pos
));
19838 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19839 p3
= get_random_num (0, sizeof (grp_pos
));
19840 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19848 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19850 char mem
[BLOCK_SIZE
];
19852 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19854 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19856 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19858 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19860 int out_len
= in_len
;
19861 int mem_len
= in_len
;
19863 memcpy (out
, in
, out_len
);
19867 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19869 int upos
; int upos2
;
19872 switch (rule
[rule_pos
])
19877 case RULE_OP_MANGLE_NOOP
:
19880 case RULE_OP_MANGLE_LREST
:
19881 out_len
= mangle_lrest (out
, out_len
);
19884 case RULE_OP_MANGLE_UREST
:
19885 out_len
= mangle_urest (out
, out_len
);
19888 case RULE_OP_MANGLE_LREST_UFIRST
:
19889 out_len
= mangle_lrest (out
, out_len
);
19890 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19893 case RULE_OP_MANGLE_UREST_LFIRST
:
19894 out_len
= mangle_urest (out
, out_len
);
19895 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19898 case RULE_OP_MANGLE_TREST
:
19899 out_len
= mangle_trest (out
, out_len
);
19902 case RULE_OP_MANGLE_TOGGLE_AT
:
19903 NEXT_RULEPOS (rule_pos
);
19904 NEXT_RPTOI (rule
, rule_pos
, upos
);
19905 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19908 case RULE_OP_MANGLE_REVERSE
:
19909 out_len
= mangle_reverse (out
, out_len
);
19912 case RULE_OP_MANGLE_DUPEWORD
:
19913 out_len
= mangle_double (out
, out_len
);
19916 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19917 NEXT_RULEPOS (rule_pos
);
19918 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19919 out_len
= mangle_double_times (out
, out_len
, ulen
);
19922 case RULE_OP_MANGLE_REFLECT
:
19923 out_len
= mangle_reflect (out
, out_len
);
19926 case RULE_OP_MANGLE_ROTATE_LEFT
:
19927 mangle_rotate_left (out
, out_len
);
19930 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19931 mangle_rotate_right (out
, out_len
);
19934 case RULE_OP_MANGLE_APPEND
:
19935 NEXT_RULEPOS (rule_pos
);
19936 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19939 case RULE_OP_MANGLE_PREPEND
:
19940 NEXT_RULEPOS (rule_pos
);
19941 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19944 case RULE_OP_MANGLE_DELETE_FIRST
:
19945 out_len
= mangle_delete_at (out
, out_len
, 0);
19948 case RULE_OP_MANGLE_DELETE_LAST
:
19949 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19952 case RULE_OP_MANGLE_DELETE_AT
:
19953 NEXT_RULEPOS (rule_pos
);
19954 NEXT_RPTOI (rule
, rule_pos
, upos
);
19955 out_len
= mangle_delete_at (out
, out_len
, upos
);
19958 case RULE_OP_MANGLE_EXTRACT
:
19959 NEXT_RULEPOS (rule_pos
);
19960 NEXT_RPTOI (rule
, rule_pos
, upos
);
19961 NEXT_RULEPOS (rule_pos
);
19962 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19963 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19966 case RULE_OP_MANGLE_OMIT
:
19967 NEXT_RULEPOS (rule_pos
);
19968 NEXT_RPTOI (rule
, rule_pos
, upos
);
19969 NEXT_RULEPOS (rule_pos
);
19970 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19971 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19974 case RULE_OP_MANGLE_INSERT
:
19975 NEXT_RULEPOS (rule_pos
);
19976 NEXT_RPTOI (rule
, rule_pos
, upos
);
19977 NEXT_RULEPOS (rule_pos
);
19978 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19981 case RULE_OP_MANGLE_OVERSTRIKE
:
19982 NEXT_RULEPOS (rule_pos
);
19983 NEXT_RPTOI (rule
, rule_pos
, upos
);
19984 NEXT_RULEPOS (rule_pos
);
19985 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
19988 case RULE_OP_MANGLE_TRUNCATE_AT
:
19989 NEXT_RULEPOS (rule_pos
);
19990 NEXT_RPTOI (rule
, rule_pos
, upos
);
19991 out_len
= mangle_truncate_at (out
, out_len
, upos
);
19994 case RULE_OP_MANGLE_REPLACE
:
19995 NEXT_RULEPOS (rule_pos
);
19996 NEXT_RULEPOS (rule_pos
);
19997 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20000 case RULE_OP_MANGLE_PURGECHAR
:
20001 NEXT_RULEPOS (rule_pos
);
20002 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20005 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20009 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20010 NEXT_RULEPOS (rule_pos
);
20011 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20012 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20015 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20016 NEXT_RULEPOS (rule_pos
);
20017 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20018 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20021 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20022 out_len
= mangle_dupechar (out
, out_len
);
20025 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20026 NEXT_RULEPOS (rule_pos
);
20027 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20028 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20031 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20032 NEXT_RULEPOS (rule_pos
);
20033 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20034 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20037 case RULE_OP_MANGLE_SWITCH_FIRST
:
20038 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20041 case RULE_OP_MANGLE_SWITCH_LAST
:
20042 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20045 case RULE_OP_MANGLE_SWITCH_AT
:
20046 NEXT_RULEPOS (rule_pos
);
20047 NEXT_RPTOI (rule
, rule_pos
, upos
);
20048 NEXT_RULEPOS (rule_pos
);
20049 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20050 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20053 case RULE_OP_MANGLE_CHR_SHIFTL
:
20054 NEXT_RULEPOS (rule_pos
);
20055 NEXT_RPTOI (rule
, rule_pos
, upos
);
20056 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20059 case RULE_OP_MANGLE_CHR_SHIFTR
:
20060 NEXT_RULEPOS (rule_pos
);
20061 NEXT_RPTOI (rule
, rule_pos
, upos
);
20062 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20065 case RULE_OP_MANGLE_CHR_INCR
:
20066 NEXT_RULEPOS (rule_pos
);
20067 NEXT_RPTOI (rule
, rule_pos
, upos
);
20068 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20071 case RULE_OP_MANGLE_CHR_DECR
:
20072 NEXT_RULEPOS (rule_pos
);
20073 NEXT_RPTOI (rule
, rule_pos
, upos
);
20074 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20077 case RULE_OP_MANGLE_REPLACE_NP1
:
20078 NEXT_RULEPOS (rule_pos
);
20079 NEXT_RPTOI (rule
, rule_pos
, upos
);
20080 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20083 case RULE_OP_MANGLE_REPLACE_NM1
:
20084 NEXT_RULEPOS (rule_pos
);
20085 NEXT_RPTOI (rule
, rule_pos
, upos
);
20086 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20089 case RULE_OP_MANGLE_TITLE
:
20090 out_len
= mangle_title (out
, out_len
);
20093 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20094 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20095 NEXT_RULEPOS (rule_pos
);
20096 NEXT_RPTOI (rule
, rule_pos
, upos
);
20097 NEXT_RULEPOS (rule_pos
);
20098 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20099 NEXT_RULEPOS (rule_pos
);
20100 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20101 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20104 case RULE_OP_MANGLE_APPEND_MEMORY
:
20105 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20106 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20107 memcpy (out
+ out_len
, mem
, mem_len
);
20108 out_len
+= mem_len
;
20111 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20112 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20113 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20114 memcpy (mem
+ mem_len
, out
, out_len
);
20115 out_len
+= mem_len
;
20116 memcpy (out
, mem
, out_len
);
20119 case RULE_OP_MEMORIZE_WORD
:
20120 memcpy (mem
, out
, out_len
);
20124 case RULE_OP_REJECT_LESS
:
20125 NEXT_RULEPOS (rule_pos
);
20126 NEXT_RPTOI (rule
, rule_pos
, upos
);
20127 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20130 case RULE_OP_REJECT_GREATER
:
20131 NEXT_RULEPOS (rule_pos
);
20132 NEXT_RPTOI (rule
, rule_pos
, upos
);
20133 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20136 case RULE_OP_REJECT_CONTAIN
:
20137 NEXT_RULEPOS (rule_pos
);
20138 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20141 case RULE_OP_REJECT_NOT_CONTAIN
:
20142 NEXT_RULEPOS (rule_pos
);
20143 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20146 case RULE_OP_REJECT_EQUAL_FIRST
:
20147 NEXT_RULEPOS (rule_pos
);
20148 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20151 case RULE_OP_REJECT_EQUAL_LAST
:
20152 NEXT_RULEPOS (rule_pos
);
20153 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20156 case RULE_OP_REJECT_EQUAL_AT
:
20157 NEXT_RULEPOS (rule_pos
);
20158 NEXT_RPTOI (rule
, rule_pos
, upos
);
20159 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20160 NEXT_RULEPOS (rule_pos
);
20161 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20164 case RULE_OP_REJECT_CONTAINS
:
20165 NEXT_RULEPOS (rule_pos
);
20166 NEXT_RPTOI (rule
, rule_pos
, upos
);
20167 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20168 NEXT_RULEPOS (rule_pos
);
20169 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20170 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20173 case RULE_OP_REJECT_MEMORY
:
20174 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20178 return (RULE_RC_SYNTAX_ERROR
);
20183 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);